diff --git a/Cargo.lock b/Cargo.lock index aa34373dd70..fda47c5df20 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -11648,6 +11648,7 @@ dependencies = [ "vortex-file", "vortex-io", "vortex-layout", + "vortex-session", "vortex-utils", ] diff --git a/encodings/alp/benches/alp_compress.rs b/encodings/alp/benches/alp_compress.rs index fd9d92a47d3..a904762d8f2 100644 --- a/encodings/alp/benches/alp_compress.rs +++ b/encodings/alp/benches/alp_compress.rs @@ -19,8 +19,15 @@ use vortex_alp::decompress_into_array; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_buffer::buffer; @@ -30,6 +37,7 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -56,7 +64,14 @@ const BENCH_ARGS: &[(usize, f64, f64)] = &[ ]; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_alp::initialize(&session); session }); diff --git a/encodings/alp/src/alp/array.rs b/encodings/alp/src/alp/array.rs index 3f73318ea10..5e667eba8b0 100644 --- a/encodings/alp/src/alp/array.rs +++ b/encodings/alp/src/alp/array.rs @@ -492,7 +492,7 @@ mod tests { use crate::decompress_into_array; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp/compress.rs b/encodings/alp/src/alp/compress.rs index 63539c71b57..024c95f82e3 100644 --- a/encodings/alp/src/alp/compress.rs +++ b/encodings/alp/src/alp/compress.rs @@ -171,7 +171,7 @@ mod tests { use crate::decompress_into_array; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp/compute/between.rs b/encodings/alp/src/alp/compute/between.rs index 44116833a27..48e2e7fb5ee 100644 --- a/encodings/alp/src/alp/compute/between.rs +++ b/encodings/alp/src/alp/compute/between.rs @@ -155,7 +155,7 @@ mod tests { use crate::alp_encode; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp/compute/cast.rs b/encodings/alp/src/alp/compute/cast.rs index 8f25815a341..6b05ed7d949 100644 --- a/encodings/alp/src/alp/compute/cast.rs +++ b/encodings/alp/src/alp/compute/cast.rs @@ -66,7 +66,7 @@ mod tests { use crate::alp_encode; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp/compute/compare.rs b/encodings/alp/src/alp/compute/compare.rs index 83044e22023..457aacee172 100644 --- a/encodings/alp/src/alp/compute/compare.rs +++ b/encodings/alp/src/alp/compute/compare.rs @@ -173,7 +173,7 @@ mod tests { use crate::alp_encode; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp/compute/filter.rs b/encodings/alp/src/alp/compute/filter.rs index 8c7212cdeab..eb5036bab47 100644 --- a/encodings/alp/src/alp/compute/filter.rs +++ b/encodings/alp/src/alp/compute/filter.rs @@ -41,17 +41,21 @@ impl FilterKernel for ALP { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::filter::test_filter_conformance; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::alp_encode; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(buffer![1.23f32, 4.56, 7.89, 10.11, 12.13].into_array())] #[case(buffer![100.1f64, 200.2, 300.3, 400.4, 500.5].into_array())] @@ -62,7 +66,7 @@ mod test { 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0 ].into_array())] fn test_filter_alp_conformance(#[case] array: ArrayRef) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array_primitive = array.execute::(&mut ctx).unwrap(); let alp = alp_encode(array_primitive.as_view(), None, &mut ctx).unwrap(); test_filter_conformance(&alp.into_array(), &mut ctx); diff --git a/encodings/alp/src/alp/compute/mask.rs b/encodings/alp/src/alp/compute/mask.rs index 37f912e5eca..b67848ca6a4 100644 --- a/encodings/alp/src/alp/compute/mask.rs +++ b/encodings/alp/src/alp/compute/mask.rs @@ -49,20 +49,24 @@ impl MaskKernel for ALP { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::mask::test_mask_conformance; use vortex_array::dtype::Nullability; use vortex_array::scalar_fn::fns::mask::MaskKernel; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::alp::array::ALPArrayExt; use crate::alp_encode; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(buffer![10.5f32, 20.5, 30.5, 40.5, 50.5].into_array())] #[case(buffer![1000.123f64, 2000.456, 3000.789, 4000.012, 5000.345].into_array())] @@ -73,7 +77,7 @@ mod test { 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0 ].into_array())] fn test_mask_alp_conformance(#[case] array: vortex_array::ArrayRef) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array_primitive = array.execute::(&mut ctx).unwrap(); let alp = alp_encode(array_primitive.as_view(), None, &mut ctx).unwrap(); test_mask_conformance(&alp.into_array(), &mut ctx); @@ -82,7 +86,7 @@ mod test { #[test] fn test_mask_alp_with_patches() { use std::f64::consts::PI; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // PI doesn't encode cleanly with ALP, so it creates patches. let values: Vec = (0..100) .map(|i| if i % 4 == 3 { PI } else { 1.0 }) @@ -95,7 +99,7 @@ mod test { #[test] fn test_mask_alp_with_patches_casts_surviving_patch_values_to_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::from_iter([1.234f32, f32::NAN, 2.345, f32::INFINITY, 3.456]); let alp = alp_encode(values.as_view(), None, &mut ctx).unwrap(); assert!(alp.patches().is_some(), "expected patches"); diff --git a/encodings/alp/src/alp/compute/mod.rs b/encodings/alp/src/alp/compute/mod.rs index 83a6c667893..262d9ebf61b 100644 --- a/encodings/alp/src/alp/compute/mod.rs +++ b/encodings/alp/src/alp/compute/mod.rs @@ -17,7 +17,6 @@ mod tests { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array; use vortex_array::compute::conformance::consistency::test_array_consistency; @@ -27,34 +26,34 @@ mod tests { use crate::alp_encode; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); #[rstest] // Basic float arrays - #[case::f32_array(alp_encode(PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] - #[case::f64_array(alp_encode(PrimitiveArray::from_iter([100.1f64, 200.2, 300.3, 400.4, 500.5]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] + #[case::f32_array(alp_encode(PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] + #[case::f64_array(alp_encode(PrimitiveArray::from_iter([100.1f64, 200.2, 300.3, 400.4, 500.5]).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] // Nullable arrays - #[case::nullable_f32(alp_encode(PrimitiveArray::from_option_iter([Some(1.1f32), None, Some(2.2), Some(3.3), None]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] - #[case::nullable_f64(alp_encode(PrimitiveArray::from_option_iter([Some(1.1f64), None, Some(2.2), Some(3.3), None]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] + #[case::nullable_f32(alp_encode(PrimitiveArray::from_option_iter([Some(1.1f32), None, Some(2.2), Some(3.3), None]).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] + #[case::nullable_f64(alp_encode(PrimitiveArray::from_option_iter([Some(1.1f64), None, Some(2.2), Some(3.3), None]).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] // Edge cases - #[case::single_element(alp_encode(PrimitiveArray::from_iter([42.42f64]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] + #[case::single_element(alp_encode(PrimitiveArray::from_iter([42.42f64]).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] // Large arrays - #[case::large_f32(alp_encode(PrimitiveArray::from_iter((0..1000).map(|i| i as f32 * 0.1)).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] + #[case::large_f32(alp_encode(PrimitiveArray::from_iter((0..1000).map(|i| i as f32 * 0.1)).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] // Arrays with patterns - #[case::repeating_pattern(alp_encode(PrimitiveArray::from_iter([1.1f32, 2.2, 3.3, 1.1, 2.2, 3.3, 1.1, 2.2, 3.3]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] - #[case::close_values(alp_encode(PrimitiveArray::from_iter([100.001f64, 100.002, 100.003, 100.004, 100.005]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] + #[case::repeating_pattern(alp_encode(PrimitiveArray::from_iter([1.1f32, 2.2, 3.3, 1.1, 2.2, 3.3, 1.1, 2.2, 3.3]).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] + #[case::close_values(alp_encode(PrimitiveArray::from_iter([100.001f64, 100.002, 100.003, 100.004, 100.005]).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] fn test_alp_consistency(#[case] array: ALPArray) { test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[rstest] - #[case::f32_basic(alp_encode(PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] - #[case::f64_basic(alp_encode(PrimitiveArray::from_iter([100.1f64, 200.2, 300.3, 400.4, 500.5]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] - #[case::f32_large(alp_encode(PrimitiveArray::from_iter((0..100).map(|i| i as f32 * 1.5)).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] - #[case::f64_large(alp_encode(PrimitiveArray::from_iter((0..100).map(|i| i as f64 * 2.5)).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())] + #[case::f32_basic(alp_encode(PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] + #[case::f64_basic(alp_encode(PrimitiveArray::from_iter([100.1f64, 200.2, 300.3, 400.4, 500.5]).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] + #[case::f32_large(alp_encode(PrimitiveArray::from_iter((0..100).map(|i| i as f32 * 1.5)).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] + #[case::f64_large(alp_encode(PrimitiveArray::from_iter((0..100).map(|i| i as f64 * 2.5)).as_view(), None, &mut SESSION.create_execution_ctx()).unwrap())] fn test_alp_binary_numeric(#[case] array: ALPArray) { test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx()); } diff --git a/encodings/alp/src/alp/compute/take.rs b/encodings/alp/src/alp/compute/take.rs index 2c34b73c6e4..2a7d26b3af3 100644 --- a/encodings/alp/src/alp/compute/take.rs +++ b/encodings/alp/src/alp/compute/take.rs @@ -32,23 +32,27 @@ impl TakeExecute for ALP { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::take::test_take_conformance; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::alp_encode; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(buffer![1.23f32, 4.56, 7.89, 10.11, 12.13].into_array())] #[case(buffer![100.1f64, 200.2, 300.3, 400.4, 500.5].into_array())] #[case(PrimitiveArray::from_option_iter([Some(1.1f32), None, Some(2.2), Some(3.3), None]).into_array())] #[case(buffer![42.42f64].into_array())] fn test_take_alp_conformance(#[case] array: vortex_array::ArrayRef) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array_primitive = array.execute::(&mut ctx).unwrap(); let alp = alp_encode(array_primitive.as_view(), None, &mut ctx).unwrap(); test_take_conformance(&alp.into_array(), &mut ctx); diff --git a/encodings/alp/src/alp/plugin.rs b/encodings/alp/src/alp/plugin.rs index 142437312ff..b72893efb32 100644 --- a/encodings/alp/src/alp/plugin.rs +++ b/encodings/alp/src/alp/plugin.rs @@ -119,7 +119,7 @@ mod tests { use crate::alp_encode; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(ALPPatchedPlugin); session }); diff --git a/encodings/alp/src/alp_rd/array.rs b/encodings/alp/src/alp_rd/array.rs index ca7421e788f..71a450585a6 100644 --- a/encodings/alp/src/alp_rd/array.rs +++ b/encodings/alp/src/alp_rd/array.rs @@ -580,7 +580,7 @@ mod test { use crate::alp_rd; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp_rd/compute/cast.rs b/encodings/alp/src/alp_rd/compute/cast.rs index 42ca8cfc47f..70e1affeee9 100644 --- a/encodings/alp/src/alp_rd/compute/cast.rs +++ b/encodings/alp/src/alp_rd/compute/cast.rs @@ -47,10 +47,11 @@ impl CastReduce for ALPRD { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; use vortex_array::builtins::ArrayBuiltins; @@ -58,13 +59,16 @@ mod tests { use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; + use vortex_session::VortexSession; use crate::RDEncoder; use crate::RDEncoderExt; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_cast_alprd_f32_to_f64() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![1.0f32, 1.1, 1.2, 1.3, 1.4]; let arr = PrimitiveArray::from_iter(values.clone()); let encoder = RDEncoder::new(&values); @@ -85,7 +89,7 @@ mod tests { #[test] fn test_cast_alprd_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::from_option_iter([Some(10.0f64), None, Some(10.1), Some(10.2), None]); let values = vec![10.0f64, 10.1, 10.2]; @@ -147,9 +151,6 @@ mod tests { encoder.encode(arr.as_view()) })] fn test_cast_alprd_conformance(#[case] alprd: crate::alp_rd::ALPRDArray) { - test_cast_conformance( - &alprd.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_cast_conformance(&alprd.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/alp/src/alp_rd/compute/filter.rs b/encodings/alp/src/alp_rd/compute/filter.rs index 62f4985546d..c3b899fd3b1 100644 --- a/encodings/alp/src/alp_rd/compute/filter.rs +++ b/encodings/alp/src/alp_rd/compute/filter.rs @@ -46,7 +46,6 @@ mod test { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; use vortex_array::compute::conformance::filter::test_filter_conformance; @@ -62,7 +61,7 @@ mod test { use crate::RDEncoderExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp_rd/compute/mask.rs b/encodings/alp/src/alp_rd/compute/mask.rs index 2fc55aff988..9ffcfa06375 100644 --- a/encodings/alp/src/alp_rd/compute/mask.rs +++ b/encodings/alp/src/alp_rd/compute/mask.rs @@ -38,7 +38,6 @@ mod tests { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::mask::test_mask_conformance; use vortex_array::dtype::NativePType; @@ -49,7 +48,7 @@ mod tests { use crate::RDEncoderExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp_rd/compute/mod.rs b/encodings/alp/src/alp_rd/compute/mod.rs index c89ae057087..d7f2b5164ee 100644 --- a/encodings/alp/src/alp_rd/compute/mod.rs +++ b/encodings/alp/src/alp_rd/compute/mod.rs @@ -13,7 +13,6 @@ mod tests { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array; use vortex_array::compute::conformance::consistency::test_array_consistency; @@ -24,7 +23,7 @@ mod tests { use crate::RDEncoderExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp_rd/compute/take.rs b/encodings/alp/src/alp_rd/compute/take.rs index ede7bc969a5..b105d7ff951 100644 --- a/encodings/alp/src/alp_rd/compute/take.rs +++ b/encodings/alp/src/alp_rd/compute/take.rs @@ -64,7 +64,6 @@ mod test { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; use vortex_array::compute::conformance::take::test_take_conformance; @@ -77,7 +76,7 @@ mod test { use crate::RDEncoderExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/alp/src/alp_rd/ops.rs b/encodings/alp/src/alp_rd/ops.rs index 255ee1c8085..024686172c7 100644 --- a/encodings/alp/src/alp_rd/ops.rs +++ b/encodings/alp/src/alp_rd/ops.rs @@ -85,7 +85,7 @@ mod test { use crate::RDEncoderExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/bytebool/src/array.rs b/encodings/bytebool/src/array.rs index 737934c9cac..9413cbaa8b4 100644 --- a/encodings/bytebool/src/array.rs +++ b/encodings/bytebool/src/array.rs @@ -337,7 +337,7 @@ mod tests { use super::*; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); @@ -379,7 +379,7 @@ mod tests { let array = ByteBool::from_option_vec(vec![Some(true), None, Some(false), None]); let dtype = array.dtype().clone(); let len = array.len(); - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(ByteBool); let ctx = ArrayContext::empty(); diff --git a/encodings/bytebool/src/compute.rs b/encodings/bytebool/src/compute.rs index ac63c52368c..6a92a039ec8 100644 --- a/encodings/bytebool/src/compute.rs +++ b/encodings/bytebool/src/compute.rs @@ -174,7 +174,6 @@ mod tests { use rstest::rstest; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::assert_arrays_eq; use vortex_array::builtins::ArrayBuiltins; @@ -191,7 +190,7 @@ mod tests { use crate::ByteBoolArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); @@ -353,7 +352,7 @@ mod tests { #[case::single_null(bb_opt(vec![None]))] #[case::mixed_with_nulls(bb_opt(vec![Some(true), None, Some(false), None, Some(true)]))] fn test_bytebool_consistency(#[case] array: ByteBoolArray) { - let ctx = &mut array_session().create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); test_array_consistency(&array.into_array(), ctx); } } diff --git a/encodings/bytebool/src/lib.rs b/encodings/bytebool/src/lib.rs index a803dacd776..e2f7be4b859 100644 --- a/encodings/bytebool/src/lib.rs +++ b/encodings/bytebool/src/lib.rs @@ -16,7 +16,8 @@ //! to a canonical [`BoolArray`][vortex_array::arrays::BoolArray]: //! //! ``` -//! # use vortex_array::{IntoArray, VortexSessionExecute, array_session}; +//! # use vortex_array::{IntoArray, VortexSessionExecute}; +//! # use vortex_session::VortexSession; //! # use vortex_array::arrays::BoolArray; //! # use vortex_array::arrays::bool::BoolArrayExt; //! # use vortex_array::buffer::BufferHandle; @@ -25,7 +26,7 @@ //! # use vortex_bytebool::ByteBool; //! # use vortex_error::VortexResult; //! # fn main() -> VortexResult<()> { -//! # let mut ctx = array_session().create_execution_ctx(); +//! # let mut ctx = VortexSession::empty().create_execution_ctx(); //! let handle = BufferHandle::new_host(ByteBuffer::from(vec![0u8, 1, 42, 0])); //! let array = ByteBool::new(handle, Validity::NonNullable); //! diff --git a/encodings/datetime-parts/benches/split_temporal.rs b/encodings/datetime-parts/benches/split_temporal.rs index 0b079972e95..940c0a29a53 100644 --- a/encodings/datetime-parts/benches/split_temporal.rs +++ b/encodings/datetime-parts/benches/split_temporal.rs @@ -12,9 +12,16 @@ use rand::SeedableRng as _; use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::TemporalArray; +use vortex_array::dtype::session::DTypeSession; use vortex_array::extension::datetime::TimeUnit; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_datetime_parts::split_temporal; @@ -24,10 +31,20 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const BENCH_ARGS: &[(usize, TimeUnit)] = &[ (65_536, TimeUnit::Seconds), diff --git a/encodings/datetime-parts/src/canonical.rs b/encodings/datetime-parts/src/canonical.rs index bdf7ba7a09c..0b375d84b2d 100644 --- a/encodings/datetime-parts/src/canonical.rs +++ b/encodings/datetime-parts/src/canonical.rs @@ -186,7 +186,7 @@ mod test { use crate::canonical::decode_to_temporal; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/datetime-parts/src/compress.rs b/encodings/datetime-parts/src/compress.rs index 1198257ebae..d84f4b6be91 100644 --- a/encodings/datetime-parts/src/compress.rs +++ b/encodings/datetime-parts/src/compress.rs @@ -170,27 +170,31 @@ fn split_slice_seconds( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::TemporalArray; use vortex_array::extension::datetime::TimeUnit; use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexExpect; + use vortex_session::VortexSession; use crate::TemporalParts; use crate::split_temporal; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(Validity::NonNullable)] #[case(Validity::AllValid)] #[case(Validity::AllInvalid)] #[case(Validity::from_iter([true, false, true]))] fn test_split_temporal(#[case] validity: Validity) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let milliseconds = PrimitiveArray::new( buffer![ 86_400i64, // element with only day component diff --git a/encodings/datetime-parts/src/compute/cast.rs b/encodings/datetime-parts/src/compute/cast.rs index fbfb6f87e39..8d5b0cd2e2c 100644 --- a/encodings/datetime-parts/src/compute/cast.rs +++ b/encodings/datetime-parts/src/compute/cast.rs @@ -33,12 +33,13 @@ impl CastReduce for DateTimeParts { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::TemporalArray; use vortex_array::builtins::ArrayBuiltins; @@ -47,10 +48,13 @@ mod tests { use vortex_array::extension::datetime::TimeUnit; use vortex_array::validity::Validity; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::DateTimeParts; use crate::DateTimePartsArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn date_time_array(validity: Validity) -> ArrayRef { DateTimeParts::try_from_temporal( TemporalArray::new_timestamp( @@ -66,7 +70,7 @@ mod tests { TimeUnit::Milliseconds, Some("UTC".into()), ), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap() .into_array() @@ -95,7 +99,7 @@ mod tests { #[case(Validity::AllInvalid)] #[case(Validity::from_iter([true, false, true]))] fn test_bad_cast_fails(#[case] validity: Validity) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = date_time_array(validity); // Cast to incompatible type - force evaluation via execute:: let result = array @@ -121,7 +125,7 @@ mod tests { ].into_array(), TimeUnit::Milliseconds, Some("UTC".into()) - ), &mut array_session().create_execution_ctx()).unwrap())] + ), &mut SESSION.create_execution_ctx()).unwrap())] #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp( PrimitiveArray::from_option_iter([ Some(0i64), @@ -132,17 +136,14 @@ mod tests { ]).into_array(), TimeUnit::Milliseconds, Some("UTC".into()) - ), &mut array_session().create_execution_ctx()).unwrap())] + ), &mut SESSION.create_execution_ctx()).unwrap())] #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp( buffer![86_400_000_000_000i64].into_array(), // 1 day in ns TimeUnit::Nanoseconds, Some("UTC".into()) - ), &mut array_session().create_execution_ctx()).unwrap())] + ), &mut SESSION.create_execution_ctx()).unwrap())] fn test_cast_datetime_parts_conformance(#[case] array: DateTimePartsArray) { use vortex_array::compute::conformance::cast::test_cast_conformance; - test_cast_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_cast_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/datetime-parts/src/compute/compare.rs b/encodings/datetime-parts/src/compute/compare.rs index 5b0685709b6..f0c9b287bea 100644 --- a/encodings/datetime-parts/src/compute/compare.rs +++ b/encodings/datetime-parts/src/compute/compare.rs @@ -246,12 +246,13 @@ fn compare_dtp( #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayRef; use vortex_array::ExecutionCtx; use vortex_array::VortexSessionExecute; use vortex_array::aggregate_fn::fns::sum::sum; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::PrimitiveArray; @@ -265,11 +266,14 @@ mod test { use vortex_array::scalar_fn::fns::binary::CompareKernel; use vortex_array::validity::Validity; use vortex_buffer::buffer; + use vortex_session::VortexSession; use super::*; use crate::DateTimeParts; use crate::DateTimePartsArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn dtp_array_from_timestamp( value: T, validity: Validity, @@ -280,7 +284,7 @@ mod test { TimeUnit::Seconds, Some("UTC".into()), ), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .expect("Failed to construct DateTimePartsArray from TemporalArray") } @@ -300,7 +304,7 @@ mod test { #[case(Validity::AllValid, Validity::NonNullable)] #[case(Validity::AllValid, Validity::AllValid)] fn compare_date_time_parts_eq(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = dtp_array_from_timestamp(86400i64, lhs_validity); // January 2, 1970, 00:00:00 UTC let rhs = dtp_array_from_timestamp(86400i64, rhs_validity.clone()); // January 2, 1970, 00:00:00 UTC let comparison = lhs @@ -324,7 +328,7 @@ mod test { #[case(Validity::AllValid, Validity::NonNullable)] #[case(Validity::AllValid, Validity::AllValid)] fn compare_date_time_parts_ne(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = dtp_array_from_timestamp(86400i64, lhs_validity); // January 2, 1970, 00:00:00 UTC let rhs = dtp_array_from_timestamp(86401i64, rhs_validity.clone()); // January 2, 1970, 00:00:01 UTC let comparison = lhs @@ -348,7 +352,7 @@ mod test { #[case(Validity::AllValid, Validity::NonNullable)] #[case(Validity::AllValid, Validity::AllValid)] fn compare_date_time_parts_lt(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = dtp_array_from_timestamp(0i64, lhs_validity); // January 1, 1970, 01:00:00 UTC let rhs = dtp_array_from_timestamp(86400i64, rhs_validity); // January 2, 1970, 00:00:00 UTC @@ -365,7 +369,7 @@ mod test { #[case(Validity::AllValid, Validity::NonNullable)] #[case(Validity::AllValid, Validity::AllValid)] fn compare_date_time_parts_gt(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = dtp_array_from_timestamp(86400i64, lhs_validity); // January 2, 1970, 02:00:00 UTC let rhs = dtp_array_from_timestamp(0i64, rhs_validity); // January 1, 1970, 01:00:00 UTC @@ -385,7 +389,7 @@ mod test { #[case] lhs_validity: Validity, #[case] rhs_validity: Validity, ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let temporal_array = TemporalArray::new_timestamp( PrimitiveArray::new(buffer![0i64], lhs_validity.clone()).into_array(), TimeUnit::Seconds, @@ -438,7 +442,7 @@ mod test { fn compare_date_time_parts_eq_out_of_range_seconds_constant() -> VortexResult<()> { const QUERY_TIMESTAMP_MS: i64 = 1_786_576_785_621; - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); let mut ctx = session.create_execution_ctx(); let timestamp = Scalar::extension::( @@ -469,7 +473,7 @@ mod test { // 1969-12-31, which splits to a day of `-1`: below the minimum of an unsigned days array. const BEFORE_EPOCH_MS: i64 = -86_400_000; - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); let mut ctx = session.create_execution_ctx(); let timestamp = Scalar::extension::( @@ -506,7 +510,7 @@ mod test { #[case] days_validity: Validity, #[case] expected: [Option; 2], ) -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); let mut ctx = session.create_execution_ctx(); // 1969-12-31, a day of `-1`: below the minimum of an unsigned days array. @@ -564,7 +568,7 @@ mod test { unit: TimeUnit, constants: impl IntoIterator, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let temporal = TemporalArray::new_timestamp(timestamps.into_array(), unit, Some("UTC".into())); let array = DateTimeParts::try_from_temporal(temporal.clone(), &mut ctx)?; @@ -642,7 +646,7 @@ mod test { #[test] fn null_rows_stay_null_when_parts_differ() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Row 1 is null and its stored seconds differ from the constant's. let values = PrimitiveArray::new( buffer![86_400i64 + 5, 86_400i64 + 7, 86_400i64 + 5], diff --git a/encodings/datetime-parts/src/compute/filter.rs b/encodings/datetime-parts/src/compute/filter.rs index 6578467eddd..65a46a77472 100644 --- a/encodings/datetime-parts/src/compute/filter.rs +++ b/encodings/datetime-parts/src/compute/filter.rs @@ -26,20 +26,24 @@ impl FilterReduce for DateTimeParts { #[cfg(test)] mod test { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::TemporalArray; use vortex_array::compute::conformance::filter::test_filter_conformance; use vortex_array::extension::datetime::TimeUnit; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::DateTimeParts; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_filter_datetime_parts() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create temporal arrays and convert to DateTimePartsArray let timestamps = buffer![ 0i64, diff --git a/encodings/datetime-parts/src/compute/mod.rs b/encodings/datetime-parts/src/compute/mod.rs index 4196b6b9832..7f3ae3740bc 100644 --- a/encodings/datetime-parts/src/compute/mod.rs +++ b/encodings/datetime-parts/src/compute/mod.rs @@ -13,22 +13,25 @@ mod take; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::TemporalArray; use vortex_array::compute::conformance::consistency::test_array_consistency; use vortex_array::extension::datetime::TimeUnit; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::DateTimeParts; use crate::DateTimePartsArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn dtp_from_temporal(temporal: TemporalArray) -> DateTimePartsArray { - DateTimeParts::try_from_temporal(temporal, &mut array_session().create_execution_ctx()) - .unwrap() + DateTimeParts::try_from_temporal(temporal, &mut SESSION.create_execution_ctx()).unwrap() } #[rstest] @@ -79,7 +82,7 @@ mod tests { )))] fn test_datetime_parts_consistency(#[case] array: DateTimePartsArray) { - let ctx = &mut array_session().create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); test_array_consistency(&array.into_array(), ctx); } } diff --git a/encodings/datetime-parts/src/compute/rules.rs b/encodings/datetime-parts/src/compute/rules.rs index 2a0fe873116..5712b94961d 100644 --- a/encodings/datetime-parts/src/compute/rules.rs +++ b/encodings/datetime-parts/src/compute/rules.rs @@ -180,9 +180,10 @@ fn is_constant_zero(array: &ArrayRef) -> bool { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::ArrayRef; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::TemporalArray; @@ -196,11 +197,14 @@ mod tests { use vortex_array::scalar_fn::fns::operators::Operator; use vortex_array::validity::Validity; use vortex_buffer::Buffer; + use vortex_session::VortexSession; use super::*; use crate::DateTimeParts; use crate::DateTimePartsArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + const SECONDS_PER_DAY: i64 = 86400; /// Create a DTP array with the given day values (all at midnight). @@ -222,7 +226,7 @@ mod tests { time_unit, None, ); - DateTimeParts::try_from_temporal(temporal, &mut array_session().create_execution_ctx()) + DateTimeParts::try_from_temporal(temporal, &mut SESSION.create_execution_ctx()) .vortex_expect("TemporalArray must produce valid DateTimeParts") } @@ -282,7 +286,7 @@ mod tests { let optimized = comparison.optimize().unwrap(); // Verify correctness: days [0, 1, 2] <= 1 should give [true, true, false] - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( optimized, BoolArray::from_iter([true, true, false]), @@ -316,7 +320,7 @@ mod tests { let optimized = between.optimize().unwrap(); // Verify correctness: days [0, 1, 2, 3, 4] between 1 and 3 should give [false, true, true, true, false] - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( optimized, BoolArray::from_iter([false, true, true, true, false]), @@ -353,7 +357,7 @@ mod tests { let optimized = comparison.optimize()?; assert_eq!(optimized.dtype(), comparison.dtype()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( optimized, BoolArray::from_iter([Some(true), Some(true), Some(false)]), @@ -378,7 +382,7 @@ mod tests { let optimized = comparison.optimize().unwrap(); // days [0, 1, 2] at midnight <= day 1 at noon: [true, true, false] - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( optimized, BoolArray::from_iter([true, true, false]), @@ -400,7 +404,7 @@ mod tests { TimeUnit::Seconds, None, ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtp = DateTimeParts::try_from_temporal(temporal, &mut ctx).unwrap(); let len = dtp.len(); diff --git a/encodings/datetime-parts/src/compute/take.rs b/encodings/datetime-parts/src/compute/take.rs index 2b49cfaa15d..7ca56f55b97 100644 --- a/encodings/datetime-parts/src/compute/take.rs +++ b/encodings/datetime-parts/src/compute/take.rs @@ -94,19 +94,23 @@ impl TakeExecute for DateTimeParts { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::TemporalArray; use vortex_array::compute::conformance::take::test_take_conformance; use vortex_array::extension::datetime::TimeUnit; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::DateTimeParts; use crate::DateTimePartsArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp( buffer![ @@ -118,7 +122,7 @@ mod tests { ].into_array(), TimeUnit::Milliseconds, Some("UTC".into()) - ), &mut array_session().create_execution_ctx()).unwrap())] + ), &mut SESSION.create_execution_ctx()).unwrap())] #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp( PrimitiveArray::from_option_iter([ Some(0i64), @@ -129,16 +133,13 @@ mod tests { ]).into_array(), TimeUnit::Milliseconds, Some("UTC".into()) - ), &mut array_session().create_execution_ctx()).unwrap())] + ), &mut SESSION.create_execution_ctx()).unwrap())] #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp( buffer![86_400_000i64].into_array(), TimeUnit::Milliseconds, Some("UTC".into()) - ), &mut array_session().create_execution_ctx()).unwrap())] + ), &mut SESSION.create_execution_ctx()).unwrap())] fn test_take_datetime_parts_conformance(#[case] array: DateTimePartsArray) { - test_take_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/decimal-byte-parts/benches/dbp_assemble.rs b/encodings/decimal-byte-parts/benches/dbp_assemble.rs index be2f205be0d..6bb5d8511a5 100644 --- a/encodings/decimal-byte-parts/benches/dbp_assemble.rs +++ b/encodings/decimal-byte-parts/benches/dbp_assemble.rs @@ -27,6 +27,8 @@ use crate::common::i256_values; static GLOBAL: MiMalloc = MiMalloc; fn main() { + #[cfg(not(codspeed))] + std::sync::LazyLock::force(&arrays::SESSION); divan::main(); } @@ -102,28 +104,48 @@ fn dbp_assemble_kernel_narrow_msp(bencher: Bencher, (values_type, len): (Decimal /// are more volatile and should not be run in CI due to noise. #[cfg(not(codspeed))] mod arrays { + use std::sync::LazyLock; + use divan::Bencher; use divan::black_box; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; + use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::dtype::DecimalDType; use vortex_array::dtype::DecimalType; + use vortex_array::dtype::session::DTypeSession; + use vortex_array::memory::MemorySession; + use vortex_array::optimizer::kernels::KernelSession; + use vortex_array::scalar_fn::session::ScalarFnSession; + use vortex_array::session::ArraySession; + use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_decimal_byte_parts::_benchmarking::assemble_decimal; use vortex_decimal_byte_parts::split_decimal; use vortex_error::VortexExpect; use vortex_error::vortex_panic; + use vortex_session::VortexSession; use crate::common::arrays::cases; use crate::common::arrays::decimal_array; + pub(super) static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + }); + #[divan::bench(args = cases())] fn dbp_assemble(bencher: Bencher, (values_type, len): (DecimalType, usize)) { let decimal = decimal_array(values_type, len, Validity::NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let parts = split_decimal(&decimal, &mut ctx).vortex_expect("split benchmark input"); bench_parts( bencher, @@ -162,9 +184,8 @@ mod arrays { lower_parts: Vec, decimal_dtype: DecimalDType, ) { - let session = array_session(); bencher - .with_inputs(|| session.create_execution_ctx()) + .with_inputs(|| SESSION.create_execution_ctx()) .bench_refs(|ctx| { assemble_decimal(black_box(&msp), black_box(&lower_parts), decimal_dtype, ctx) .vortex_expect("assemble decimal byte parts") diff --git a/encodings/decimal-byte-parts/benches/dbp_split.rs b/encodings/decimal-byte-parts/benches/dbp_split.rs index d3a6100f500..84d90944e19 100644 --- a/encodings/decimal-byte-parts/benches/dbp_split.rs +++ b/encodings/decimal-byte-parts/benches/dbp_split.rs @@ -27,6 +27,8 @@ use crate::common::i256_values; static GLOBAL: MiMalloc = MiMalloc; fn main() { + #[cfg(not(codspeed))] + std::sync::LazyLock::force(&arrays::SESSION); divan::main(); } @@ -74,21 +76,41 @@ fn bench_split(bencher: Bencher, values_type: DecimalType, len: usize, validity: /// are more volatile and should not be run in CI due to noise. #[cfg(not(codspeed))] mod arrays { + use std::sync::LazyLock; + use divan::Bencher; use divan::black_box; use rand::RngExt; use rand::SeedableRng; use rand::rngs::StdRng; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; + use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::dtype::DecimalType; + use vortex_array::dtype::session::DTypeSession; + use vortex_array::memory::MemorySession; + use vortex_array::optimizer::kernels::KernelSession; + use vortex_array::scalar_fn::session::ScalarFnSession; + use vortex_array::session::ArraySession; + use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_decimal_byte_parts::split_decimal; use vortex_error::VortexExpect; + use vortex_session::VortexSession; use crate::common::arrays::cases; use crate::common::arrays::decimal_array; + pub(super) static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + }); + #[divan::bench(args = cases())] fn dbp_split_all_valid(bencher: Bencher, (values_type, len): (DecimalType, usize)) { bench_split(bencher, values_type, len, Validity::AllValid); @@ -108,9 +130,8 @@ mod arrays { fn bench_split(bencher: Bencher, values_type: DecimalType, len: usize, validity: Validity) { let decimal = decimal_array(values_type, len, validity); - let session = array_session(); bencher - .with_inputs(|| session.create_execution_ctx()) + .with_inputs(|| SESSION.create_execution_ctx()) .bench_refs(|ctx| { split_decimal(black_box(&decimal), ctx).vortex_expect("split decimal array") }); diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/array.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/array.rs index 93a228a3a87..7b60b349023 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/array.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/array.rs @@ -410,13 +410,14 @@ impl ValidityChild for DecimalByteParts { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::Array; use vortex_array::ArrayParts; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::PrimitiveArray; @@ -434,6 +435,7 @@ mod tests { use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::DecimalByteParts; use super::DecimalBytePartsArraySlotsExt; @@ -443,6 +445,8 @@ mod tests { use crate::decimal_byte_parts::testing::i128_parts; use crate::decimal_byte_parts::testing::i256_parts; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_scalar_at_decimal_parts() { let decimal_dtype = DecimalDType::new(8, 2); @@ -461,7 +465,7 @@ mod tests { assert_eq!( Scalar::null(dtype.clone()), array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_eq!( @@ -471,13 +475,13 @@ mod tests { ) .unwrap(), array - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_eq!( Scalar::try_new(dtype, Some(ScalarValue::Decimal(DecimalValue::I64(400)))).unwrap(), array - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() ); } @@ -489,7 +493,7 @@ mod tests { assert_eq!(array.msp().dtype().as_ptype(), PType::I64); assert_eq!(array.lower_parts()[0].dtype(), &LOWER_PART_DTYPE); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let msp = array.msp().clone().execute::(&mut ctx)?; let lower = array.lower_parts()[0] .clone() @@ -507,7 +511,7 @@ mod tests { ); assert_eq!(array.lower_parts().len(), MAX_LOWER_PARTS); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let msp = array.msp().clone().execute::(&mut ctx)?; assert_eq!(msp.as_slice::(), &[5]); for (part, expected) in array.lower_parts().iter().zip([6u64, 7, 8]) { @@ -535,7 +539,7 @@ mod tests { .collect(); let dtype = DecimalDType::new(if lower_count <= 1 { 38 } else { 76 }, 0); let array = DecimalByteParts::try_new_with_lower_parts(msp.into_array(), lower, dtype)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let canonical = array .clone() .into_array() @@ -556,7 +560,7 @@ mod tests { Validity::Array(BoolArray::from_iter([false, true, true]).into_array()), ) .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( array.execute_scalar(0, &mut ctx)?, Scalar::null(array.dtype().clone()) @@ -582,7 +586,7 @@ mod tests { #[values(PType::I8, PType::I16, PType::I32, PType::I64)] msp_ptype: PType, #[values(1, 2, 3)] lower_count: usize, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let validity = Validity::from_iter([false, true, true]); let msp = PrimitiveArray::new(buffer![0i64, 1, -1], validity.clone()) .into_array() @@ -692,7 +696,7 @@ mod tests { #[test] fn test_wide_decimal_buffer_types() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let i128_array = i128_parts(vec![1i128 << 100], Validity::NonNullable); let canonical = i128_array.into_array().execute::(&mut ctx)?; @@ -744,7 +748,7 @@ mod tests { )? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( array.execute_scalar(0, &mut ctx)?, Scalar::null(array.dtype().clone()) diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/assemble.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/assemble.rs index 2b890396b92..df222241964 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/assemble.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/assemble.rs @@ -199,10 +199,11 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::Constant; use vortex_array::arrays::DecimalArray; @@ -219,10 +220,13 @@ mod tests { use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::assemble_decimal; use crate::decimal_byte_parts::split_decimal; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::empty_non_nullable(0, Validity::NonNullable)] #[case::empty_nullable(0, Validity::AllValid)] @@ -242,7 +246,7 @@ mod tests { )] values_type: DecimalType, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal = match_each_decimal_value_type!(values_type, |T| { DecimalArray::new( Buffer::::zeroed(len), @@ -276,7 +280,7 @@ mod tests { #[values(false, true)] wide_256: bool, #[values(0, 1, 63, 64, 65, 257)] len: usize, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal = if wide_256 { DecimalArray::new( buffer![i256::from_i128(-1); 263], @@ -310,7 +314,7 @@ mod tests { } fn round_trip(decimal: DecimalArray) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let parts = split_decimal(&decimal, &mut ctx)?; assemble_decimal( &parts.msp, @@ -367,7 +371,7 @@ mod tests { #[values(Validity::NonNullable, Validity::from_iter([true, false, true]))] validity: Validity, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal = DecimalArray::new(buffer![1i32, 2, 3], DecimalDType::new(2, 0), validity); let parts = split_decimal(&decimal, &mut ctx)?; assert!(parts.lower_parts.is_empty()); @@ -400,7 +404,7 @@ mod tests { .into_iter() .map(IntoArray::into_array) .collect::>(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(assemble_decimal(&msp.into_array(), &lower, dtype, &mut ctx).is_err()); } @@ -419,7 +423,7 @@ mod tests { .into_iter() .map(IntoArray::into_array) .collect::>(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(assemble_decimal(&msp.into_array(), &lower, dtype, &mut ctx).is_err()); } @@ -428,7 +432,7 @@ mod tests { #[values(false, true)] narrow_msp: bool, #[values(2, 3)] lower_count: usize, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let msp = if narrow_msp { PrimitiveArray::new(buffer![3i8, -3], Validity::NonNullable) } else { diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/between.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/between.rs index 35b6dabd2b6..8ef4d81daf3 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/between.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/between.rs @@ -133,7 +133,7 @@ mod tests { use crate::decimal_byte_parts::testing::i128_parts; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs index 03cb9902ddc..c700c6f2515 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs @@ -36,11 +36,12 @@ impl CastReduce for DecimalByteParts { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; @@ -51,13 +52,16 @@ mod tests { use vortex_array::dtype::Nullability; use vortex_array::validity::Validity; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::DecimalByteParts; use crate::DecimalBytePartsArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_cast_decimal_byte_parts_nullability() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(10, 2); let array = DecimalByteParts::try_new(buffer![100i32, 200, 300, 400].into_array(), decimal_dtype) @@ -87,7 +91,7 @@ mod tests { #[test] fn test_cast_decimal_byte_parts_nullable_to_non_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(10, 2); let array = DecimalByteParts::try_new( PrimitiveArray::from_option_iter([Some(100i32), None, Some(300)]).into_array(), @@ -126,9 +130,6 @@ mod tests { DecimalDType::new(10, 2), ).unwrap())] fn test_cast_decimal_byte_parts_conformance(#[case] array: DecimalBytePartsArray) { - test_cast_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_cast_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs index 8c5169342d8..4626b325215 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs @@ -176,7 +176,7 @@ mod tests { use crate::decimal_byte_parts::testing::i128_parts; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs index 6921e5dfda4..6224d8b91a8 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs @@ -21,20 +21,24 @@ impl FilterReduce for DecimalByteParts { #[cfg(test)] mod test { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::filter::test_filter_conformance; use vortex_array::dtype::DecimalDType; use vortex_array::dtype::i256; use vortex_array::validity::Validity; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::DecimalByteParts; use crate::decimal_byte_parts::testing::i128_parts; use crate::decimal_byte_parts::testing::i256_parts; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_filter_decimal_byte_parts() { // Create test data with 5 signed integer values @@ -42,10 +46,7 @@ mod test { let decimal_dtype = DecimalDType::new(8, 2); let array = DecimalByteParts::try_new(msp, decimal_dtype).unwrap(); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); // Test with nullable values let msp = PrimitiveArray::from_option_iter([Some(10i64), None, Some(30), Some(40), None]) @@ -53,10 +54,7 @@ mod test { let decimal_dtype = DecimalDType::new(18, 4); let array = DecimalByteParts::try_new(msp, decimal_dtype).unwrap(); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[test] @@ -65,10 +63,7 @@ mod test { vec![1i128 << 70, -(1i128 << 70), 5, (1i128 << 64) - 1, 0], Validity::NonNullable, ); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); let array = i256_parts( vec![ @@ -80,9 +75,6 @@ mod test { ], Validity::from_iter([true, false, true, true, false]), ); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs index 815782f0683..d420ac5e6e1 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs @@ -13,10 +13,11 @@ mod take; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array; use vortex_array::compute::conformance::consistency::test_array_consistency; @@ -24,12 +25,19 @@ mod tests { use vortex_array::dtype::i256; use vortex_array::validity::Validity; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::DecimalByteParts; use crate::DecimalBytePartsArray; use crate::decimal_byte_parts::testing::i128_parts; use crate::decimal_byte_parts::testing::i256_parts; + static SESSION: LazyLock = LazyLock::new(|| { + let session = VortexSession::empty(); + crate::initialize(&session); + session + }); + /// Values needing more than 64 bits, so the encoding carries lower parts. fn wide_i128() -> Vec { vec![ @@ -104,9 +112,7 @@ mod tests { #[case::decimal_i256_nullable(i256_parts(wide_i256(), Validity::from_iter([false, true, true, false, true])))] fn test_decimal_byte_parts_consistency(#[case] array: DecimalBytePartsArray) { - let session = array_session(); - crate::initialize(&session); - let ctx = &mut session.create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); test_array_consistency(&array.into_array(), ctx); } @@ -126,9 +132,7 @@ mod tests { #[case::decimal_i128_one_lower_part(i128_parts(wide_i128(), Validity::NonNullable))] #[case::decimal_i256_three_lower_parts(i256_parts(wide_i256(), Validity::NonNullable))] fn test_decimal_byte_parts_binary_numeric(#[case] array: DecimalBytePartsArray) { - let session = array_session(); - crate::initialize(&session); - let ctx = &mut session.create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); test_binary_numeric_array(&array.into_array(), ctx); } } diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/take.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/take.rs index 08df92b46d2..6a2ca24f390 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/take.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/take.rs @@ -30,10 +30,11 @@ impl TakeReduce for DecimalByteParts { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; @@ -43,24 +44,28 @@ mod tests { use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::DecimalByteParts; + static SESSION: LazyLock = LazyLock::new(|| { + let session = VortexSession::empty(); + crate::initialize(&session); + session + }); + /// Taking pushes down into the parts during optimization, with no execution context in /// play: `ArrayRef::take` wraps the array in a `Dict` and optimizes, and the reduce rule /// must rewrite that into a `DecimalByteParts` of taken parts. #[test] fn take_pushes_down_without_executing() -> VortexResult<()> { - let session = array_session(); - crate::initialize(&session); - let decimal = DecimalArray::new( Buffer::from(vec![1i128 << 70, 2, 3]), DecimalDType::new(38, 2), Validity::NonNullable, ); let indices = buffer![0u64, 2].into_array(); - let taken = DecimalByteParts::encode(&decimal, &mut session.create_execution_ctx())? + let taken = DecimalByteParts::encode(&decimal, &mut SESSION.create_execution_ctx())? .into_array() .take(indices)?; @@ -86,7 +91,7 @@ mod tests { Validity::NonNullable, ))] fn take_with_nullable_indices(#[case] decimal: DecimalArray) -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); let mut ctx = session.create_execution_ctx(); diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/tests.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/tests.rs index e76476ac39e..8f8e2202c52 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/tests.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/tests.rs @@ -1,13 +1,14 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use prost::Message as _; use rstest::rstest; use vortex_array::ArrayContext; use vortex_array::ArrayDeserialization; use vortex_array::ArrayVTable; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::Primitive; @@ -25,6 +26,7 @@ use vortex_array::validity::Validity; use vortex_buffer::ByteBufferMut; use vortex_buffer::buffer; use vortex_error::VortexExpect; +use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use super::*; @@ -32,6 +34,8 @@ use crate::DecimalBytePartsArray; use crate::DecimalBytePartsArraySlotsExt; use crate::decimal_byte_parts::MAX_LOWER_PARTS; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::no_lower_parts(DecimalByteParts::try_new( buffer![1i32, 2, 3].into_array(), DecimalDType::new(9, 2), @@ -41,18 +45,18 @@ use crate::decimal_byte_parts::MAX_LOWER_PARTS; ))] #[case::wider_i64_storage(DecimalByteParts::encode( &DecimalArray::new(buffer![-99i64, 0, 99], DecimalDType::new(2, 0), Validity::NonNullable), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ))] #[case::wider_i128_storage(DecimalByteParts::encode( &DecimalArray::new(buffer![-99i128, 0, 99], DecimalDType::new(2, 0), Validity::NonNullable), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ))] #[case::wider_i256_storage(DecimalByteParts::encode( &DecimalArray::new( buffer![i256::from_i128(-99), i256::ZERO, i256::from_i128(99)], DecimalDType::new(2, 0), Validity::NonNullable, ), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ))] #[case::redundant_lower_parts(DecimalByteParts::try_new_with_lower_parts( buffer![0i64; 3].into_array(), @@ -246,7 +250,7 @@ fn serialization_requires_v2_permission() -> VortexResult<()> { #[test] fn bare_vtable_refuses_serde() -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); session.arrays().register(DecimalByteParts); let msp = msp(); let array = DecimalByteParts::try_new(msp.clone(), DecimalDType::new(19, 2))?.into_array(); @@ -305,7 +309,7 @@ fn v2_metadata(lower_part_ptypes: Vec) -> Vec { } fn session() -> VortexSession { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session } @@ -319,6 +323,6 @@ fn deserialize_with( let dtype = DType::Decimal(DecimalDType::new(38, 2), Nullability::NonNullable); DecimalBytePartsPlugin.deserialize( ArrayDeserialization::new(serialized_id, &dtype, 3, metadata, &[], &children), - &array_session(), + &VortexSession::empty(), ) } diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/prop_tests.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/prop_tests.rs index f7c32fba9cf..1e742d7bda0 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/prop_tests.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/prop_tests.rs @@ -9,7 +9,6 @@ use vortex_array::ArrayRef; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; @@ -18,6 +17,7 @@ use vortex_array::dtype::i256; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_error::VortexExpect; +use vortex_session::VortexSession; use super::DecimalByteParts; use super::DecimalBytePartsArray; @@ -34,7 +34,7 @@ const MAX_I256_HIGH: i128 = 10i128.pow(37); const MAX_LEN: usize = 48; fn ctx() -> ExecutionCtx { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session.create_execution_ctx() } diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/split.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/split.rs index 8057e82f301..cb274ed0cbf 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/split.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/split.rs @@ -238,9 +238,10 @@ pub const fn i256_to_parts(value: i256) -> (i64, [u64; MAX_I256_LOWER_PARTS]) { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; @@ -251,14 +252,17 @@ mod tests { use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::split_decimal; use crate::decimal_byte_parts::LOWER_PART_DTYPE; use crate::decimal_byte_parts::MAX_LOWER_PARTS; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_split_i256_part_count_and_types() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal = DecimalArray::new( Buffer::from(vec![i256::from_i128(i128::MAX), i256::MIN]), DecimalDType::new(76, 0), @@ -278,7 +282,7 @@ mod tests { #[values(Validity::NonNullable, Validity::from_iter([true, false, true]))] validity: Validity, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal = DecimalArray::new( buffer![ i256::from_parts((2u128 << 64) | 3, (1i128 << 64) | 4), diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/testing.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/testing.rs index af270bad407..74d9dc456ab 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/testing.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/testing.rs @@ -3,23 +3,27 @@ //! Shared fixtures for decimal byte-parts tests. +use std::sync::LazyLock; + use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::DecimalArray; use vortex_array::dtype::DecimalDType; use vortex_array::dtype::i256; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_error::VortexExpect; +use vortex_session::VortexSession; use super::DecimalByteParts; use super::DecimalBytePartsArray; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// An `i128`-backed decimal array, encoded as byte parts with one lower part. pub(crate) fn i128_parts(values: Vec, validity: Validity) -> DecimalBytePartsArray { DecimalByteParts::encode( &DecimalArray::new(Buffer::from(values), DecimalDType::new(38, 2), validity), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .vortex_expect("valid decimal byte parts") } @@ -28,7 +32,7 @@ pub(crate) fn i128_parts(values: Vec, validity: Validity) -> DecimalBytePa pub(crate) fn i256_parts(values: Vec, validity: Validity) -> DecimalBytePartsArray { DecimalByteParts::encode( &DecimalArray::new(Buffer::from(values), DecimalDType::new(76, 2), validity), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .vortex_expect("valid decimal byte parts") } diff --git a/encodings/fastlanes/benches/bitpack_blocked.rs b/encodings/fastlanes/benches/bitpack_blocked.rs index 2223628e787..d49a3b2bb0c 100644 --- a/encodings/fastlanes/benches/bitpack_blocked.rs +++ b/encodings/fastlanes/benches/bitpack_blocked.rs @@ -11,7 +11,14 @@ use divan::Bencher; use divan::counter::ItemsCount; use mimalloc::MiMalloc; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_fastlanes::bitpack_compress::bitpack_encode_blocked; use vortex_session::VortexSession; @@ -19,11 +26,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/bitpack_blocked_decompress.rs b/encodings/fastlanes/benches/bitpack_blocked_decompress.rs index 73dec4f6e11..93fa07b90c8 100644 --- a/encodings/fastlanes/benches/bitpack_blocked_decompress.rs +++ b/encodings/fastlanes/benches/bitpack_blocked_decompress.rs @@ -12,8 +12,15 @@ use divan::counter::ItemsCount; use mimalloc::MiMalloc; use num_traits::AsPrimitive; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_fastlanes::BitPackedArraySlotsExt; use vortex_fastlanes::bitpack_compress::bitpack_encode_blocked; use vortex_fastlanes::bitpack_decompress::unpack_array_blocked; @@ -23,11 +30,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/bitpack_compare.rs b/encodings/fastlanes/benches/bitpack_compare.rs index 0d89e770cc1..64380422692 100644 --- a/encodings/fastlanes/benches/bitpack_compare.rs +++ b/encodings/fastlanes/benches/bitpack_compare.rs @@ -19,11 +19,18 @@ use vortex_array::ArrayRef; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::builtins::ArrayBuiltins; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Alignment; use vortex_buffer::BufferMut; @@ -37,11 +44,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/bitpack_compare_sweep.rs b/encodings/fastlanes/benches/bitpack_compare_sweep.rs index f3da868902b..602d20b7648 100644 --- a/encodings/fastlanes/benches/bitpack_compare_sweep.rs +++ b/encodings/fastlanes/benches/bitpack_compare_sweep.rs @@ -21,13 +21,20 @@ use vortex_array::ArrayRef; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Alignment; use vortex_buffer::BufferMut; @@ -41,11 +48,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/bitpacking_filter.rs b/encodings/fastlanes/benches/bitpacking_filter.rs index 77a1b080cd0..15f418b197c 100644 --- a/encodings/fastlanes/benches/bitpacking_filter.rs +++ b/encodings/fastlanes/benches/bitpacking_filter.rs @@ -13,7 +13,14 @@ use divan::counter::ItemsCount; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BufferMut; use vortex_fastlanes::BitPackedData; @@ -21,11 +28,19 @@ use vortex_mask::Mask; use vortex_session::VortexSession; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/bitpacking_take.rs b/encodings/fastlanes/benches/bitpacking_take.rs index ba2cac32499..5ac7efe8ff0 100644 --- a/encodings/fastlanes/benches/bitpacking_take.rs +++ b/encodings/fastlanes/benches/bitpacking_take.rs @@ -17,6 +17,7 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray as _; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::PiecewiseSequenceArray; use vortex_array::arrays::PrimitiveArray; @@ -24,6 +25,12 @@ use vortex_array::assert_arrays_eq; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::NativePType; use vortex_array::dtype::PType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_buffer::BufferMut; @@ -37,11 +44,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/canonicalize_bench.rs b/encodings/fastlanes/benches/canonicalize_bench.rs index 2c47656f836..b8d4bd1fb81 100644 --- a/encodings/fastlanes/benches/canonicalize_bench.rs +++ b/encodings/fastlanes/benches/canonicalize_bench.rs @@ -10,9 +10,16 @@ use rand::prelude::StdRng; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::builders::ArrayBuilder; use vortex_array::builders::PrimitiveBuilder; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_error::VortexExpect; use vortex_fastlanes::bitpack_compress::test_harness::make_array; use vortex_session::VortexSession; @@ -21,6 +28,7 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -39,7 +47,14 @@ const BENCH_ARGS: &[(usize, usize, f64)] = &[ ]; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/cast_bitpacked.rs b/encodings/fastlanes/benches/cast_bitpacked.rs index bd9d6d9f24f..2f025e2484c 100644 --- a/encodings/fastlanes/benches/cast_bitpacked.rs +++ b/encodings/fastlanes/benches/cast_bitpacked.rs @@ -22,12 +22,19 @@ use rand::prelude::StdRng; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BufferMut; use vortex_error::VortexExpect; @@ -39,11 +46,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/compute_between.rs b/encodings/fastlanes/benches/compute_between.rs index ef09c7b25e3..5ba31181757 100644 --- a/encodings/fastlanes/benches/compute_between.rs +++ b/encodings/fastlanes/benches/compute_between.rs @@ -15,8 +15,15 @@ use vortex_alp::alp_encode; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_error::VortexExpect; use vortex_fastlanes::bitpack_compress::bitpack_to_best_bit_width; use vortex_session::VortexSession; @@ -25,11 +32,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/for_decode.rs b/encodings/fastlanes/benches/for_decode.rs index 72ef7018408..0bf4bcae9aa 100644 --- a/encodings/fastlanes/benches/for_decode.rs +++ b/encodings/fastlanes/benches/for_decode.rs @@ -23,8 +23,15 @@ use mimalloc::MiMalloc; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_error::vortex_panic; @@ -40,11 +47,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/benches/for_encode.rs b/encodings/fastlanes/benches/for_encode.rs index d5ee72829e4..7b015794cf8 100644 --- a/encodings/fastlanes/benches/for_encode.rs +++ b/encodings/fastlanes/benches/for_encode.rs @@ -18,8 +18,15 @@ use divan::Bencher; use divan::counter::ItemsCount; use mimalloc::MiMalloc; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_fastlanes::FoR; @@ -29,11 +36,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fastlanes::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/array/bitpack_compress/blocked.rs b/encodings/fastlanes/src/bitpacking/array/bitpack_compress/blocked.rs index cc0105317a2..4fbe91fedb9 100644 --- a/encodings/fastlanes/src/bitpacking/array/bitpack_compress/blocked.rs +++ b/encodings/fastlanes/src/bitpacking/array/bitpack_compress/blocked.rs @@ -355,7 +355,7 @@ mod tests { use crate::bitpacking::array::BitPackedArrayExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/array/bitpack_compress/global.rs b/encodings/fastlanes/src/bitpacking/array/bitpack_compress/global.rs index 7e61427c612..53f16a0e06a 100644 --- a/encodings/fastlanes/src/bitpacking/array/bitpack_compress/global.rs +++ b/encodings/fastlanes/src/bitpacking/array/bitpack_compress/global.rs @@ -444,7 +444,7 @@ mod test { use crate::bitpacking::array::BitPackedArrayExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/array/bitpack_decompress/global.rs b/encodings/fastlanes/src/bitpacking/array/bitpack_decompress/global.rs index d6cc50afbd4..3cdf080edec 100644 --- a/encodings/fastlanes/src/bitpacking/array/bitpack_decompress/global.rs +++ b/encodings/fastlanes/src/bitpacking/array/bitpack_decompress/global.rs @@ -244,7 +244,7 @@ mod tests { } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/array/mod.rs b/encodings/fastlanes/src/bitpacking/array/mod.rs index 7dd8a38d3ca..323bee8c7d8 100644 --- a/encodings/fastlanes/src/bitpacking/array/mod.rs +++ b/encodings/fastlanes/src/bitpacking/array/mod.rs @@ -538,7 +538,7 @@ mod test { use crate::bitpacking::array::BitPackedArrayExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/array/tests.rs b/encodings/fastlanes/src/bitpacking/array/tests.rs index 6d93db1f3a1..94a29adff73 100644 --- a/encodings/fastlanes/src/bitpacking/array/tests.rs +++ b/encodings/fastlanes/src/bitpacking/array/tests.rs @@ -41,7 +41,7 @@ use crate::FoR; use crate::bitpacking::bitpack_compress::bitpack_to_best_bit_width; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs b/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs index d84ae4d9c10..e6993e83a62 100644 --- a/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs +++ b/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs @@ -61,13 +61,14 @@ impl> UnpackStrategy for BitPackingStr /// #[gat(Item)] /// use lending_iterator::prelude::LendingIterator; /// use vortex_array::IntoArray; +/// use vortex_session::VortexSession; /// use vortex_array::VortexSessionExecute; /// use vortex_buffer::buffer; /// use vortex_fastlanes::BitPackedData; /// use vortex_fastlanes::BitPackedArrayExt; /// use vortex_fastlanes::unpack_iter::BitUnpackedChunks; /// -/// let mut ctx = vortex_array::array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// let array = BitPackedData::encode(&buffer![2, 3, 4, 5].into_array(), 2, &mut ctx).unwrap(); /// let mut scratch = [const { MaybeUninit::::uninit() }; 1024]; /// let mut unpacked_chunks: BitUnpackedChunks = diff --git a/encodings/fastlanes/src/bitpacking/compute/between.rs b/encodings/fastlanes/src/bitpacking/compute/between.rs index 558079f7cd7..a878fcb3c05 100644 --- a/encodings/fastlanes/src/bitpacking/compute/between.rs +++ b/encodings/fastlanes/src/bitpacking/compute/between.rs @@ -238,7 +238,7 @@ mod tests { use crate::BitPackedData; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/compute/cast.rs b/encodings/fastlanes/src/bitpacking/compute/cast.rs index b41a3dbb14f..8203e68a6b7 100644 --- a/encodings/fastlanes/src/bitpacking/compute/cast.rs +++ b/encodings/fastlanes/src/bitpacking/compute/cast.rs @@ -147,7 +147,7 @@ mod tests { use crate::BitPackedData; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/compute/compare.rs b/encodings/fastlanes/src/bitpacking/compute/compare.rs index 3b6b02c7b2f..68389b6eb2b 100644 --- a/encodings/fastlanes/src/bitpacking/compute/compare.rs +++ b/encodings/fastlanes/src/bitpacking/compute/compare.rs @@ -214,7 +214,7 @@ mod tests { use crate::BitPackedData; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/compute/filter.rs b/encodings/fastlanes/src/bitpacking/compute/filter.rs index b9aa2fdea79..0b1fde8621f 100644 --- a/encodings/fastlanes/src/bitpacking/compute/filter.rs +++ b/encodings/fastlanes/src/bitpacking/compute/filter.rs @@ -162,7 +162,7 @@ mod tests { use crate::bitpacking::array::BitPackedArrayExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/compute/is_constant.rs b/encodings/fastlanes/src/bitpacking/compute/is_constant.rs index 0ad8005ba0f..857de993de0 100644 --- a/encodings/fastlanes/src/bitpacking/compute/is_constant.rs +++ b/encodings/fastlanes/src/bitpacking/compute/is_constant.rs @@ -191,18 +191,22 @@ fn apply_patches_idx_typed( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::aggregate_fn::fns::is_constant::is_constant; - use vortex_array::array_session; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::BitPackedData; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn is_constant_with_patches() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = BitPackedData::encode(&buffer![4; 1025].into_array(), 2, &mut ctx)?; assert!(is_constant(&array.into_array(), &mut ctx)?); Ok(()) diff --git a/encodings/fastlanes/src/bitpacking/compute/mod.rs b/encodings/fastlanes/src/bitpacking/compute/mod.rs index 5951247256e..08f499752cd 100644 --- a/encodings/fastlanes/src/bitpacking/compute/mod.rs +++ b/encodings/fastlanes/src/bitpacking/compute/mod.rs @@ -83,26 +83,24 @@ fn chunked_indices( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array; use vortex_array::compute::conformance::consistency::test_array_consistency; + use vortex_session::VortexSession; use crate::BitPackedArray; use crate::bitpack_compress::bitpack_encode; use crate::bitpacking::compute::chunked_indices; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn bp(array: &PrimitiveArray, bit_width: u8) -> BitPackedArray { - bitpack_encode( - array, - bit_width, - None, - &mut array_session().create_execution_ctx(), - ) - .unwrap() + bitpack_encode(array, bit_width, None, &mut SESSION.create_execution_ctx()).unwrap() } #[test] @@ -147,7 +145,7 @@ mod tests { #[case::alternating_bits(bp(&PrimitiveArray::from_iter([0u16, 255, 0, 255, 0, 255]), 8))] fn test_bitpacked_consistency(#[case] array: BitPackedArray) { - let ctx = &mut array_session().create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); test_array_consistency(&array.into_array(), ctx); } @@ -159,9 +157,6 @@ mod tests { #[case::i32_basic(bp(&PrimitiveArray::from_iter([10i32, 20, 30, 40, 50]), 7))] #[case::large_u32(bp(&PrimitiveArray::from_iter((0..100).map(|i| i as u32)), 7))] fn test_bitpacked_binary_numeric(#[case] array: BitPackedArray) { - test_binary_numeric_array( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/fastlanes/src/bitpacking/compute/slice.rs b/encodings/fastlanes/src/bitpacking/compute/slice.rs index 93cb829da97..b51df224d40 100644 --- a/encodings/fastlanes/src/bitpacking/compute/slice.rs +++ b/encodings/fastlanes/src/bitpacking/compute/slice.rs @@ -79,20 +79,24 @@ fn slice_bitpacked( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::SliceArray; use vortex_array::assert_arrays_eq; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::BitPacked; use crate::bitpack_compress::bitpack_encode; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_reduce_parent_returns_bitpacked_slice() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::from_iter(0u32..2048); let bitpacked = bitpack_encode(&values, 11, None, &mut ctx)?; diff --git a/encodings/fastlanes/src/bitpacking/compute/take.rs b/encodings/fastlanes/src/bitpacking/compute/take.rs index 1dddd75a545..345cbef80da 100644 --- a/encodings/fastlanes/src/bitpacking/compute/take.rs +++ b/encodings/fastlanes/src/bitpacking/compute/take.rs @@ -421,7 +421,7 @@ mod tests { use crate::bitpacking::compute::take::unpack_chunk_threshold; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/bitpacking/plugin/tests.rs b/encodings/fastlanes/src/bitpacking/plugin/tests.rs index a5cf98400c3..127695c6d26 100644 --- a/encodings/fastlanes/src/bitpacking/plugin/tests.rs +++ b/encodings/fastlanes/src/bitpacking/plugin/tests.rs @@ -47,7 +47,7 @@ use crate::bitpack_compress::bitpack_blocked_to_best_bit_widths; use crate::bitpack_compress::bitpack_encode_blocked; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(BitPackedPatchedPlugin); session }); @@ -187,7 +187,7 @@ fn primitive_array_returns_error() -> VortexResult<()> { } static PLUGIN_SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(BitPackedPlugin); session }); @@ -245,7 +245,7 @@ fn serde_roundtrip( fn vtable_serde_requires_plugin() -> VortexResult<()> { let values = PrimitiveArray::from_iter([1u8, 2, 3]).into_array(); let array = BitPackedData::encode(&values, 2, &mut SESSION.create_execution_ctx())?; - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(BitPacked); assert!(session.array_serialize(&array.into_array()).is_err()); Ok(()) diff --git a/encodings/fastlanes/src/bitpacking/vtable/operations.rs b/encodings/fastlanes/src/bitpacking/vtable/operations.rs index 060315a7eb3..1eeabc15906 100644 --- a/encodings/fastlanes/src/bitpacking/vtable/operations.rs +++ b/encodings/fastlanes/src/bitpacking/vtable/operations.rs @@ -43,7 +43,6 @@ mod test { use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::SliceArray; use vortex_array::assert_arrays_eq; @@ -231,7 +230,7 @@ mod test { #[test] fn scalar_at_invalid_patches() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let packed_array = BitPacked::try_new( BufferHandle::new_host(ByteBuffer::copy_from_aligned( [0u8; 128], diff --git a/encodings/fastlanes/src/delta/array/delta_compress.rs b/encodings/fastlanes/src/delta/array/delta_compress.rs index 8eda6e7cff1..71df4078523 100644 --- a/encodings/fastlanes/src/delta/array/delta_compress.rs +++ b/encodings/fastlanes/src/delta/array/delta_compress.rs @@ -116,7 +116,7 @@ mod tests { use crate::delta_compress; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/delta/array/mod.rs b/encodings/fastlanes/src/delta/array/mod.rs index 6b1079d0e4f..271a74d5343 100644 --- a/encodings/fastlanes/src/delta/array/mod.rs +++ b/encodings/fastlanes/src/delta/array/mod.rs @@ -46,7 +46,7 @@ pub struct DeltaSlots { /// use vortex_session::VortexSession; /// use vortex_fastlanes::Delta; /// -/// let session = vortex_array::array_session(); +/// let session = VortexSession::empty(); /// let primitive = PrimitiveArray::from_iter([1_u32, 2, 3, 5, 10, 11]); /// let array = Delta::try_from_primitive_array(&primitive, &mut session.create_execution_ctx()).unwrap(); /// ``` @@ -61,7 +61,7 @@ pub struct DeltaSlots { /// use vortex_session::VortexSession; /// use vortex_fastlanes::Delta; /// -/// let session = vortex_array::array_session(); +/// let session = VortexSession::empty(); /// let primitive = PrimitiveArray::from_iter([-3_i32, -2, -1, 0, 1, 2]); /// let array = Delta::try_from_primitive_array(&primitive, &mut session.create_execution_ctx()).unwrap(); /// ``` diff --git a/encodings/fastlanes/src/delta/compute/cast.rs b/encodings/fastlanes/src/delta/compute/cast.rs index 658d3ddb2e0..4342fd883bd 100644 --- a/encodings/fastlanes/src/delta/compute/cast.rs +++ b/encodings/fastlanes/src/delta/compute/cast.rs @@ -71,7 +71,7 @@ mod tests { use crate::Delta; use crate::DeltaArraySlotsExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/delta/tests.rs b/encodings/fastlanes/src/delta/tests.rs index c785ca5bdcb..37bc80e8e00 100644 --- a/encodings/fastlanes/src/delta/tests.rs +++ b/encodings/fastlanes/src/delta/tests.rs @@ -36,7 +36,7 @@ use crate::FL_CHUNK_SIZE; use crate::bitpack_compress::bitpack_encode; fn session() -> VortexSession { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session } diff --git a/encodings/fastlanes/src/delta/vtable/operations.rs b/encodings/fastlanes/src/delta/vtable/operations.rs index 072063c5d6a..8448605135c 100644 --- a/encodings/fastlanes/src/delta/vtable/operations.rs +++ b/encodings/fastlanes/src/delta/vtable/operations.rs @@ -33,7 +33,6 @@ mod tests { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array; @@ -48,7 +47,7 @@ mod tests { use crate::DeltaArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/delta/vtable/validity.rs b/encodings/fastlanes/src/delta/vtable/validity.rs index 7118208a439..3133e07cdf2 100644 --- a/encodings/fastlanes/src/delta/vtable/validity.rs +++ b/encodings/fastlanes/src/delta/vtable/validity.rs @@ -44,7 +44,7 @@ mod tests { use crate::delta::array::delta_compress::delta_compress; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/for_/array/for_compress.rs b/encodings/fastlanes/src/for_/array/for_compress.rs index acdd6a4ab89..cd854bab5fa 100644 --- a/encodings/fastlanes/src/for_/array/for_compress.rs +++ b/encodings/fastlanes/src/for_/array/for_compress.rs @@ -282,7 +282,6 @@ mod test { use itertools::Itertools; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::primitive::PrimitiveArrayExt; use vortex_array::assert_arrays_eq; use vortex_array::dtype::PType; @@ -299,7 +298,7 @@ mod test { use crate::for_::tests::global; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/for_/array/for_decompress.rs b/encodings/fastlanes/src/for_/array/for_decompress.rs index 5f49f07646a..30aed5808b9 100644 --- a/encodings/fastlanes/src/for_/array/for_decompress.rs +++ b/encodings/fastlanes/src/for_/array/for_decompress.rs @@ -424,7 +424,6 @@ mod tests { use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::assert_arrays_eq; use vortex_session::VortexSession; @@ -434,7 +433,7 @@ mod tests { use crate::FoRData; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/for_/compute/cast.rs b/encodings/fastlanes/src/for_/compute/cast.rs index 9bafc45c18f..af1ac50af3f 100644 --- a/encodings/fastlanes/src/for_/compute/cast.rs +++ b/encodings/fastlanes/src/for_/compute/cast.rs @@ -56,7 +56,7 @@ mod tests { use crate::FoRArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/for_/compute/compare.rs b/encodings/fastlanes/src/for_/compute/compare.rs index c70dfb49f03..d9dfcc6d9f8 100644 --- a/encodings/fastlanes/src/for_/compute/compare.rs +++ b/encodings/fastlanes/src/for_/compute/compare.rs @@ -113,7 +113,7 @@ mod tests { use crate::FoRArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/for_/compute/is_sorted.rs b/encodings/fastlanes/src/for_/compute/is_sorted.rs index cc56af3d523..504ceead01b 100644 --- a/encodings/fastlanes/src/for_/compute/is_sorted.rs +++ b/encodings/fastlanes/src/for_/compute/is_sorted.rs @@ -64,20 +64,24 @@ impl DynAggregateKernel for FoRIsSortedKernel { #[cfg(test)] mod test { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::aggregate_fn::fns::is_sorted::is_sorted; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::validity::Validity; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::FoRData; use crate::for_::array::FoRArraySlotsExt; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_sorted() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = PrimitiveArray::new(buffer![-1, 0, i8::MAX], Validity::NonNullable); let b = FoRData::encode(a, &mut ctx).unwrap(); diff --git a/encodings/fastlanes/src/for_/compute/mod.rs b/encodings/fastlanes/src/for_/compute/mod.rs index d9de8e335d2..65e5d07d215 100644 --- a/encodings/fastlanes/src/for_/compute/mod.rs +++ b/encodings/fastlanes/src/for_/compute/mod.rs @@ -49,21 +49,25 @@ impl FilterReduce for FoR { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::filter::test_filter_conformance; use vortex_array::compute::conformance::take::test_take_conformance; use vortex_array::scalar::Scalar; use vortex_buffer::buffer; use vortex_error::VortexExpect; + use vortex_session::VortexSession; use crate::FoR; use crate::FoRArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn fa(encoded: ArrayRef, reference: Scalar) -> FoRArray { FoR::try_new(encoded, reference).vortex_expect("FoR array construction should succeed") } @@ -74,27 +78,18 @@ mod test { buffer![100i32, 101, 102, 103, 104].into_array(), Scalar::from(100i32), ); - test_filter_conformance( - &for_array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&for_array.into_array(), &mut SESSION.create_execution_ctx()); let for_array = fa( buffer![1000u64, 1001, 1002, 1003, 1004].into_array(), Scalar::from(1000u64), ); - test_filter_conformance( - &for_array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&for_array.into_array(), &mut SESSION.create_execution_ctx()); let values = PrimitiveArray::from_option_iter([Some(50i16), None, Some(52), Some(53), None]); let for_array = fa(values.into_array(), Scalar::from(50i16)); - test_filter_conformance( - &for_array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&for_array.into_array(), &mut SESSION.create_execution_ctx()); } #[rstest] @@ -107,30 +102,31 @@ mod test { #[case(fa(buffer![-100i32, -99, -98, -97, -96].into_array(), Scalar::from(-100i32)))] #[case(fa(buffer![42i64].into_array(), Scalar::from(40i64)))] fn test_take_for_conformance(#[case] for_array: FoRArray) { - test_take_conformance( - &for_array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&for_array.into_array(), &mut SESSION.create_execution_ctx()); } } #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array; use vortex_array::compute::conformance::consistency::test_array_consistency; use vortex_array::scalar::Scalar; use vortex_buffer::buffer; use vortex_error::VortexExpect; + use vortex_session::VortexSession; use crate::FoR; use crate::FoRArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn fa(encoded: ArrayRef, reference: Scalar) -> FoRArray { FoR::try_new(encoded, reference).vortex_expect("FoR array construction should succeed") } @@ -164,10 +160,7 @@ mod tests { #[case::for_large_deltas(fa(buffer![100i64, 200, 300, 400, 500].into_array(), Scalar::from(100i64)))] fn test_for_consistency(#[case] array: FoRArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[rstest] @@ -180,9 +173,6 @@ mod tests { Scalar::from(2000i32) ))] fn test_for_binary_numeric(#[case] array: FoRArray) { - test_binary_numeric_array( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/fastlanes/src/for_/plugin/tests.rs b/encodings/fastlanes/src/for_/plugin/tests.rs index 6e490bd0568..16278e070df 100644 --- a/encodings/fastlanes/src/for_/plugin/tests.rs +++ b/encodings/fastlanes/src/for_/plugin/tests.rs @@ -24,7 +24,7 @@ use crate::for_::tests::blocked; use crate::for_::tests::global; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); @@ -137,7 +137,7 @@ fn vtable_serde_requires_plugin() -> VortexResult<()> { PrimitiveArray::from_iter([1u8, 2, 3]), &mut SESSION.create_execution_ctx(), )?; - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(FoR); assert!(session.array_serialize(&array.into_array()).is_err()); Ok(()) diff --git a/encodings/fastlanes/src/for_/tests.rs b/encodings/fastlanes/src/for_/tests.rs index 18b6f3512ea..63116924f5e 100644 --- a/encodings/fastlanes/src/for_/tests.rs +++ b/encodings/fastlanes/src/for_/tests.rs @@ -39,7 +39,7 @@ use crate::FoRData; use crate::FoRReferences; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/for_/vtable/operations.rs b/encodings/fastlanes/src/for_/vtable/operations.rs index 4d5f3d9b171..afe60caf930 100644 --- a/encodings/fastlanes/src/for_/vtable/operations.rs +++ b/encodings/fastlanes/src/for_/vtable/operations.rs @@ -79,7 +79,7 @@ mod test { use crate::FoRData; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/lib.rs b/encodings/fastlanes/src/lib.rs index 905d9b45d84..eca8a27153b 100644 --- a/encodings/fastlanes/src/lib.rs +++ b/encodings/fastlanes/src/lib.rs @@ -17,7 +17,8 @@ //! session before deserializing or executing arrays that may contain these encodings. //! //! ```rust -//! let session = vortex_array::array_session(); +//! use vortex_session::VortexSession; +//! let session = VortexSession::empty(); //! vortex_fastlanes::initialize(&session); //! ``` //! @@ -179,7 +180,7 @@ mod test { use super::*; pub static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); diff --git a/encodings/fastlanes/src/rle/array/rle_compress.rs b/encodings/fastlanes/src/rle/array/rle_compress.rs index 994bb738e7a..68ec3ba575f 100644 --- a/encodings/fastlanes/src/rle/array/rle_compress.rs +++ b/encodings/fastlanes/src/rle/array/rle_compress.rs @@ -184,7 +184,7 @@ mod tests { use crate::rle::array::RLEArraySlotsExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/rle/compute/cast.rs b/encodings/fastlanes/src/rle/compute/cast.rs index a8aa7b199f0..194c6c36c3e 100644 --- a/encodings/fastlanes/src/rle/compute/cast.rs +++ b/encodings/fastlanes/src/rle/compute/cast.rs @@ -66,7 +66,7 @@ mod tests { use crate::rle::RLEArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fastlanes/src/rle/vtable/operations.rs b/encodings/fastlanes/src/rle/vtable/operations.rs index 23c43b37e1d..81bd595e31c 100644 --- a/encodings/fastlanes/src/rle/vtable/operations.rs +++ b/encodings/fastlanes/src/rle/vtable/operations.rs @@ -53,7 +53,7 @@ mod tests { use crate::RLEData; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fsst/benches/chunked_dict_fsst_builder.rs b/encodings/fsst/benches/chunked_dict_fsst_builder.rs index b19e03546c2..3a1ee27e13e 100644 --- a/encodings/fsst/benches/chunked_dict_fsst_builder.rs +++ b/encodings/fsst/benches/chunked_dict_fsst_builder.rs @@ -9,9 +9,16 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::builders::builder_with_capacity_in; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_error::VortexExpect; use vortex_fsst::test_utils::gen_dict_fsst_test_data; use vortex_session::VortexSession; @@ -20,6 +27,7 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -34,7 +42,14 @@ const BENCH_ARGS: &[(usize, usize, usize)] = &[ ]; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fsst::initialize(&session); session }); diff --git a/encodings/fsst/benches/fsst_compress.rs b/encodings/fsst/benches/fsst_compress.rs index 1b7fe8d6e0a..398db9f1d04 100644 --- a/encodings/fsst/benches/fsst_compress.rs +++ b/encodings/fsst/benches/fsst_compress.rs @@ -15,6 +15,7 @@ use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::VarBinArray; @@ -23,8 +24,14 @@ use vortex_array::builders::VarBinViewBuilder; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_fsst::fsst_compress; use vortex_fsst::fsst_train_compressor; use vortex_session::VortexSession; @@ -33,11 +40,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fsst::initialize(&session); session }); diff --git a/encodings/fsst/benches/fsst_like.rs b/encodings/fsst/benches/fsst_like.rs index d85f0666aec..123121c9d48 100644 --- a/encodings/fsst/benches/fsst_like.rs +++ b/encodings/fsst/benches/fsst_like.rs @@ -11,9 +11,16 @@ use mimalloc::MiMalloc; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ConstantArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar_fn::fns::like::Like; use vortex_array::scalar_fn::fns::like::LikeOptions; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_fsst::FSSTArray; use vortex_fsst::test_utils::NUM_STRINGS; use vortex_fsst::test_utils::make_fsst_clickbench_urls; @@ -29,11 +36,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fsst::initialize(&session); session }); diff --git a/encodings/fsst/benches/fsst_take.rs b/encodings/fsst/benches/fsst_take.rs index 321c165d783..10c29cf00fb 100644 --- a/encodings/fsst/benches/fsst_take.rs +++ b/encodings/fsst/benches/fsst_take.rs @@ -15,11 +15,18 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinArray; use vortex_array::assert_arrays_eq; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_fsst::FSSTArray; use vortex_fsst::fsst_compress; use vortex_fsst::fsst_train_compressor; @@ -29,11 +36,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fsst::initialize(&session); session }); diff --git a/encodings/fsst/benches/fsst_url_compare.rs b/encodings/fsst/benches/fsst_url_compare.rs index d9898d49e2a..75354526122 100644 --- a/encodings/fsst/benches/fsst_url_compare.rs +++ b/encodings/fsst/benches/fsst_url_compare.rs @@ -11,16 +11,23 @@ use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::VarBinArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::arrays::varbin::VarBinArrayExt; use vortex_array::builtins::ArrayBuiltins; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::like; use vortex_array::expr::lit; use vortex_array::expr::root; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_fsst::fsst_compress; use vortex_fsst::fsst_train_compressor; use vortex_fsst::test_utils::HIGH_MATCH_DOMAIN; @@ -33,11 +40,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fsst::initialize(&session); session }); diff --git a/encodings/fsst/src/array.rs b/encodings/fsst/src/array.rs index 962e65d04b0..c8cb108adf3 100644 --- a/encodings/fsst/src/array.rs +++ b/encodings/fsst/src/array.rs @@ -1048,6 +1048,8 @@ impl ValidityVTable for FSST { #[cfg(test)] mod test { + use std::sync::LazyLock; + use fsst::Compressor; use fsst::Symbol; use prost::Message; @@ -1055,7 +1057,6 @@ mod test { use vortex_array::ArrayPlugin; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::VarBinViewArray; use vortex_array::buffer::BufferHandle; use vortex_array::dtype::DType; @@ -1066,6 +1067,7 @@ mod test { use vortex_buffer::Buffer; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use crate::FSST; use crate::array::FSST_SYMBOL_TABLE_LEN; @@ -1078,6 +1080,8 @@ mod test { use crate::fsst_compress; use crate::fsst_train_compressor; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn slice_reuses_initialized_compressor() -> VortexResult<()> { let symbols = Buffer::::copy_from([ @@ -1087,7 +1091,7 @@ mod test { let symbol_lengths = Buffer::::copy_from([3, 8]); let compressor = Compressor::rebuild_from(symbols.as_slice(), symbol_lengths.as_slice()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let strings = VarBinViewArray::from_iter_str(["abcabcab", "defghijk", "abcxyz"]); let fsst_array = fsst_compress(&strings.into_array(), &compressor, &mut ctx)?; @@ -1107,7 +1111,7 @@ mod test { /// expose the populated prefix. #[test] fn symbol_table_padded_on_creation() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let strings = VarBinViewArray::from_iter_str(["abcabcab", "defghijk", "abcxyz"]); let compressor = Compressor::rebuild_from( [ @@ -1148,7 +1152,7 @@ mod test { /// them before a `Decompressor` can borrow them. #[test] fn symbol_table_padded_on_deserialize() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = VarBinViewArray::from_iter_str(["abcabcab", "defghijk"]).into_array(); let compressor = fsst_train_compressor(&input, &mut ctx)?; let fsst_array = fsst_compress(&input, &compressor, &mut ctx)?; @@ -1193,7 +1197,7 @@ mod test { &buffers, &children.as_slice(), ), - &array_session(), + &SESSION, )?; let padded = deserialized @@ -1302,7 +1306,7 @@ mod test { let symbol_lengths = Buffer::::copy_from([3, 8]); let compressor = Compressor::rebuild_from(symbols.as_slice(), symbol_lengths.as_slice()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = VarBinViewArray::from_iter_str(["abcabcab", "defghijk"]); let fsst_array = fsst_compress(&input.into_array(), &compressor, &mut ctx)?; @@ -1343,11 +1347,10 @@ mod test { &buffers, &children.as_slice(), ), - &array_session(), + &SESSION, )?; - let decompressed = - fsst.execute::(&mut array_session().create_execution_ctx())?; + let decompressed = fsst.execute::(&mut SESSION.create_execution_ctx())?; let mask = decompressed .validity()? .execute_mask(decompressed.len(), &mut ctx)?; diff --git a/encodings/fsst/src/canonical.rs b/encodings/fsst/src/canonical.rs index f584000cb16..448acdf3cc6 100644 --- a/encodings/fsst/src/canonical.rs +++ b/encodings/fsst/src/canonical.rs @@ -195,7 +195,7 @@ mod tests { use crate::fsst_compress; use crate::fsst_train_compressor; - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); fn make_data() -> (VarBinArray, Vec>>) { const STRING_COUNT: usize = 1000; diff --git a/encodings/fsst/src/compress.rs b/encodings/fsst/src/compress.rs index e931d515b5c..bb786e47175 100644 --- a/encodings/fsst/src/compress.rs +++ b/encodings/fsst/src/compress.rs @@ -353,18 +353,22 @@ impl<'c, O: OffsetBuilderPType + 'static> FsstSink<'c, O> { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::VarBinViewArray; use vortex_array::arrays::varbin::VarBinArraySlotsExt; use vortex_array::dtype::PType; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::fsst_compress; use super::fsst_output_fits_in_i32_offsets; use super::fsst_train_compressor; use crate::array::FSSTArrayExt; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Regression for #7833: the i32-vs-i64 codes-offsets decision must cross at /// `i32::MAX` against the worst-case bound `2 * total`. #[test] @@ -381,7 +385,7 @@ mod tests { #[test] fn codes_offsets_dtype_small_input_is_i32() -> VortexResult<()> { let array = VarBinViewArray::from_iter_str(["hello", "world", "fsst encoded"]); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let compressor = fsst_train_compressor(array.as_array(), &mut ctx)?; let fsst = fsst_compress(array.as_array(), &compressor, &mut ctx)?; assert_eq!(fsst.codes().offsets().dtype().as_ptype(), PType::I32); diff --git a/encodings/fsst/src/compute/cast.rs b/encodings/fsst/src/compute/cast.rs index 5c531158c94..63513cd4ba3 100644 --- a/encodings/fsst/src/compute/cast.rs +++ b/encodings/fsst/src/compute/cast.rs @@ -110,7 +110,7 @@ mod tests { use crate::initialize; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); diff --git a/encodings/fsst/src/compute/compare.rs b/encodings/fsst/src/compute/compare.rs index e9a73090a20..53422acebee 100644 --- a/encodings/fsst/src/compute/compare.rs +++ b/encodings/fsst/src/compute/compare.rs @@ -143,7 +143,7 @@ mod tests { use crate::fsst_train_compressor; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fsst/src/compute/like.rs b/encodings/fsst/src/compute/like.rs index 1026d15e5b1..380de2f82cc 100644 --- a/encodings/fsst/src/compute/like.rs +++ b/encodings/fsst/src/compute/like.rs @@ -101,7 +101,7 @@ mod tests { use crate::fsst_train_compressor; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fsst/src/compute/mod.rs b/encodings/fsst/src/compute/mod.rs index 0b95b75e1e7..01b36149a3b 100644 --- a/encodings/fsst/src/compute/mod.rs +++ b/encodings/fsst/src/compute/mod.rs @@ -155,6 +155,8 @@ fn compressed_byte_span(offsets: &ArrayRef) -> Option { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use fsst::Compressor; use fsst::Symbol; use rstest::rstest; @@ -162,7 +164,6 @@ mod tests { use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::DictArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinArray; @@ -177,6 +178,7 @@ mod tests { use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::compressed_byte_span; use crate::FSST; @@ -184,9 +186,11 @@ mod tests { use crate::fsst_compress; use crate::fsst_train_compressor; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_take_null() -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); let mut ctx = session.create_execution_ctx(); let arr = @@ -222,7 +226,7 @@ mod tests { DType::Utf8(Nullability::NonNullable), ))] fn test_take_fsst_conformance(#[case] varbin: VarBinArray) -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); let mut ctx = session.create_execution_ctx(); let varbin = varbin.into_array(); @@ -243,7 +247,7 @@ mod tests { #[case] nullable: bool, #[case] gathers: bool, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = VarBinArray::from_iter( (0..16).map(|row| { (!(nullable && row == 0)).then(|| format!("{}{row}", "caption ".repeat(repeats))) @@ -272,7 +276,7 @@ mod tests { #[test] fn test_take_small_slice_uses_logical_byte_span() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = VarBinArray::from_iter( (0..16).map(|row| Some("caption ".repeat(if row < 4 { 4096 } else { 2 }))), DType::Utf8(Nullability::NonNullable), @@ -310,7 +314,7 @@ mod tests { #[case] indices: ArrayRef, #[case] gathers: bool, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = VarBinArray::from_iter( (0..256).map(|row| Some("caption ".repeat(if row < long_rows { 8192 } else { 1 }))), DType::Utf8(Nullability::NonNullable), @@ -420,7 +424,7 @@ mod tests { })] fn test_fsst_consistency(#[case] build: FsstBuilder) { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); let mut ctx = session.create_execution_ctx(); let array = build(&mut ctx); diff --git a/encodings/fsst/src/dfa/tests.rs b/encodings/fsst/src/dfa/tests.rs index 53f20fb8b3c..c97682e27e3 100644 --- a/encodings/fsst/src/dfa/tests.rs +++ b/encodings/fsst/src/dfa/tests.rs @@ -30,7 +30,7 @@ use crate::fsst_compress; use crate::fsst_train_compressor; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fsst/src/kernel.rs b/encodings/fsst/src/kernel.rs index 86c41f6dc25..44d9c7b2531 100644 --- a/encodings/fsst/src/kernel.rs +++ b/encodings/fsst/src/kernel.rs @@ -55,7 +55,7 @@ mod tests { use crate::fsst_train_compressor; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/fsst/src/tests.rs b/encodings/fsst/src/tests.rs index 4097f738ef3..dbd9de56dcb 100644 --- a/encodings/fsst/src/tests.rs +++ b/encodings/fsst/src/tests.rs @@ -23,7 +23,7 @@ use crate::fsst_compress; use crate::fsst_train_compressor; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/onpair/benches/decode.rs b/encodings/onpair/benches/decode.rs index c04505baf37..fa19a3af50e 100644 --- a/encodings/onpair/benches/decode.rs +++ b/encodings/onpair/benches/decode.rs @@ -34,7 +34,6 @@ use vortex_array::ArrayRef; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinArray; use vortex_array::arrays::VarBinViewArray; @@ -50,6 +49,7 @@ use vortex_onpair::DEFAULT_CONFIG; use vortex_onpair::OnPair; use vortex_onpair::OnPairArray; use vortex_onpair::OnPairArraySlotsExt; +use vortex_session::VortexSession; /// Host-resident decode inputs, materialised once so the decode-loop benchmark /// measures only `onpair::decode_into` (not child `execute`/allocation). @@ -80,11 +80,24 @@ impl DecodeInputs { unsafe { onpair::decode_into(self.codes.as_slice(), self.dict(), out) } } } +use vortex_array::aggregate_fn::session::AggregateFnSession; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_onpair::onpair_compress; -use vortex_session::VortexSession; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_onpair::initialize(&session); session }); @@ -263,5 +276,6 @@ fn filter_share_dict(bencher: Bencher, case: (Shape, usize)) { static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/encodings/onpair/src/compute/cast.rs b/encodings/onpair/src/compute/cast.rs index a746d3dcc07..737b6933f8f 100644 --- a/encodings/onpair/src/compute/cast.rs +++ b/encodings/onpair/src/compute/cast.rs @@ -86,7 +86,7 @@ mod tests { use crate::compress::onpair_compress; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/onpair/src/compute/compare.rs b/encodings/onpair/src/compute/compare.rs index 131a325a0af..fe8e6a0cec3 100644 --- a/encodings/onpair/src/compute/compare.rs +++ b/encodings/onpair/src/compute/compare.rs @@ -114,7 +114,7 @@ mod tests { use crate::compress::onpair_compress; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/onpair/src/tests.rs b/encodings/onpair/src/tests.rs index f745dcb4cd4..aa735b0524a 100644 --- a/encodings/onpair/src/tests.rs +++ b/encodings/onpair/src/tests.rs @@ -39,7 +39,7 @@ use crate::OnPairMetadata; use crate::compress::onpair_compress; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); @@ -635,9 +635,7 @@ fn test_onpair_take_shares_dict() -> vortex_error::VortexResult<()> { /// A dictionary whose values are OnPair takes through the kernel instead of decoding every value. #[test] fn test_dict_over_onpair_uses_take_kernel() -> vortex_error::VortexResult<()> { - let session = vortex_array::array_session(); - crate::initialize(&session); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = take_input(); let onpair = compress_onpair(&values.clone().into_array(), &mut ctx)?; diff --git a/encodings/onpair/tests/big_data.rs b/encodings/onpair/tests/big_data.rs index faf350fee2c..80cbaeb18d0 100644 --- a/encodings/onpair/tests/big_data.rs +++ b/encodings/onpair/tests/big_data.rs @@ -32,7 +32,7 @@ use vortex_onpair::onpair_compress; use vortex_session::VortexSession; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); vortex_onpair::initialize(&session); session }); diff --git a/encodings/parquet-variant/src/array.rs b/encodings/parquet-variant/src/array.rs index 375fd143801..8a88ed61d82 100644 --- a/encodings/parquet-variant/src/array.rs +++ b/encodings/parquet-variant/src/array.rs @@ -533,7 +533,7 @@ mod tests { use crate::array::parquet_typed_value_from_logical_shredded; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/parquet-variant/src/arrow.rs b/encodings/parquet-variant/src/arrow.rs index 905d3b29db3..48d2c305c94 100644 --- a/encodings/parquet-variant/src/arrow.rs +++ b/encodings/parquet-variant/src/arrow.rs @@ -326,7 +326,7 @@ mod tests { #[fixture] fn session() -> VortexSession { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session } diff --git a/encodings/parquet-variant/src/compute/allnondistinct.rs b/encodings/parquet-variant/src/compute/allnondistinct.rs index 3c06de27046..ab0b5f0df11 100644 --- a/encodings/parquet-variant/src/compute/allnondistinct.rs +++ b/encodings/parquet-variant/src/compute/allnondistinct.rs @@ -105,7 +105,7 @@ mod tests { use crate::ParquetVariant; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/parquet-variant/src/json_to_variant_tests.rs b/encodings/parquet-variant/src/json_to_variant_tests.rs index 72bf07c9e77..e66ed56c67d 100644 --- a/encodings/parquet-variant/src/json_to_variant_tests.rs +++ b/encodings/parquet-variant/src/json_to_variant_tests.rs @@ -41,7 +41,7 @@ use crate::ShreddingSpec; use crate::json_to_variant; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/parquet-variant/src/kernel.rs b/encodings/parquet-variant/src/kernel.rs index ee66196788b..b218d9404f4 100644 --- a/encodings/parquet-variant/src/kernel.rs +++ b/encodings/parquet-variant/src/kernel.rs @@ -343,7 +343,7 @@ mod tests { use crate::ParquetVariantArraySlotsExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); vortex_uuid::initialize(&session); session diff --git a/encodings/parquet-variant/src/operations.rs b/encodings/parquet-variant/src/operations.rs index 6fab3008fda..60a60a19eca 100644 --- a/encodings/parquet-variant/src/operations.rs +++ b/encodings/parquet-variant/src/operations.rs @@ -391,7 +391,6 @@ mod tests { use parquet_variant_compute::VariantArray as ArrowVariantArray; use parquet_variant_compute::VariantArrayBuilder; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; use vortex_array::scalar::Scalar; @@ -404,7 +403,7 @@ mod tests { use crate::ParquetVariantArrayExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); @@ -461,17 +460,17 @@ mod tests { assert!( vortex_arr - .execute_scalar(1, &mut array_session().create_execution_ctx())? + .execute_scalar(1, &mut SESSION.create_execution_ctx())? .is_null() ); assert!( !vortex_arr - .execute_scalar(0, &mut array_session().create_execution_ctx())? + .execute_scalar(0, &mut SESSION.create_execution_ctx())? .is_null() ); assert!( !vortex_arr - .execute_scalar(2, &mut array_session().create_execution_ctx())? + .execute_scalar(2, &mut SESSION.create_execution_ctx())? .is_null() ); @@ -496,20 +495,18 @@ mod tests { let vortex_arr = ParquetVariant::from_arrow_variant(&arrow_variant, &SESSION.arrow())?; let present_variant_null = - vortex_arr.execute_scalar(0, &mut array_session().create_execution_ctx())?; + vortex_arr.execute_scalar(0, &mut SESSION.create_execution_ctx())?; assert!(!present_variant_null.is_null()); assert_eq!( present_variant_null.as_variant().is_variant_null(), Some(true) ); - let outer_null = - vortex_arr.execute_scalar(1, &mut array_session().create_execution_ctx())?; + let outer_null = vortex_arr.execute_scalar(1, &mut SESSION.create_execution_ctx())?; assert!(outer_null.is_null()); assert_eq!(outer_null.as_variant().is_variant_null(), None); - let present_value = - vortex_arr.execute_scalar(2, &mut array_session().create_execution_ctx())?; + let present_value = vortex_arr.execute_scalar(2, &mut SESSION.create_execution_ctx())?; assert!(!present_value.is_null()); assert_eq!(present_value.as_variant().is_variant_null(), Some(false)); @@ -535,17 +532,17 @@ mod tests { assert_eq!(vortex_arr.dtype(), &DType::Variant(Nullability::Nullable)); assert!( vortex_arr - .execute_scalar(0, &mut array_session().create_execution_ctx())? + .execute_scalar(0, &mut SESSION.create_execution_ctx())? .is_null() ); assert!( vortex_arr - .execute_scalar(1, &mut array_session().create_execution_ctx())? + .execute_scalar(1, &mut SESSION.create_execution_ctx())? .is_null() ); let inner_pv = vortex_arr.as_opt::().unwrap(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let roundtripped = inner_pv.to_arrow(&ArrowExportOptions::default(), &mut ctx)?; assert_eq!(roundtripped.inner().null_count(), 2); @@ -567,12 +564,12 @@ mod tests { ); assert!( !vortex_arr - .execute_scalar(0, &mut array_session().create_execution_ctx())? + .execute_scalar(0, &mut SESSION.create_execution_ctx())? .is_null() ); assert!( !vortex_arr - .execute_scalar(1, &mut array_session().create_execution_ctx())? + .execute_scalar(1, &mut SESSION.create_execution_ctx())? .is_null() ); assert_scalar_rows(&arrow_variant, &[Scalar::from(1i32), Scalar::from(2i32)])?; @@ -703,7 +700,7 @@ mod tests { let arrow_variant = ArrowVariantArray::try_new(&struct_array)?; let vortex_arr = ParquetVariant::from_arrow_variant(&arrow_variant, &SESSION.arrow())?; - let row0 = vortex_arr.execute_scalar(0, &mut array_session().create_execution_ctx())?; + let row0 = vortex_arr.execute_scalar(0, &mut SESSION.create_execution_ctx())?; let row0 = row0.as_variant().value().unwrap().as_list(); assert_eq!(row0.len(), 2); assert_eq!( @@ -727,7 +724,7 @@ mod tests { Some(20) ); - let row1 = vortex_arr.execute_scalar(1, &mut array_session().create_execution_ctx())?; + let row1 = vortex_arr.execute_scalar(1, &mut SESSION.create_execution_ctx())?; let row1 = row1.as_variant().value().unwrap().as_list(); assert_eq!(row1.len(), 1); assert_eq!( @@ -794,7 +791,7 @@ mod tests { let arrow_variant = ArrowVariantArray::try_new(&struct_array)?; let vortex_arr = ParquetVariant::from_arrow_variant(&arrow_variant, &SESSION.arrow())?; - let object = vortex_arr.execute_scalar(0, &mut array_session().create_execution_ctx())?; + let object = vortex_arr.execute_scalar(0, &mut SESSION.create_execution_ctx())?; let object = object.as_variant().value().unwrap().as_struct(); assert_eq!( diff --git a/encodings/parquet-variant/src/vtable.rs b/encodings/parquet-variant/src/vtable.rs index f5933bfcc1b..34703b17c45 100644 --- a/encodings/parquet-variant/src/vtable.rs +++ b/encodings/parquet-variant/src/vtable.rs @@ -348,7 +348,7 @@ mod tests { use crate::array::ParquetVariantArraySlotsExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); @@ -357,7 +357,7 @@ mod tests { let dtype = array.dtype().clone(); let len = array.len(); - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(ParquetVariant); let ctx = ArrayContext::empty(); @@ -401,7 +401,7 @@ mod tests { fn parquet_variant_file_session() -> VortexResult { const TEST_EDITION: EditionId = EditionId::new("test", 2026, 7, 0); - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::(); vortex_file::register_default_encodings(&session); diff --git a/encodings/pco/benches/scalar.rs b/encodings/pco/benches/scalar.rs index a919da948c1..6c70643e745 100644 --- a/encodings/pco/benches/scalar.rs +++ b/encodings/pco/benches/scalar.rs @@ -12,7 +12,14 @@ use mimalloc::MiMalloc; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_error::VortexExpect; use vortex_pco::Pco; @@ -22,6 +29,7 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -33,7 +41,16 @@ const CASES: &[(usize, bool, bool)] = &[ (1024, false, true), ]; -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn pco(nullable: bool) -> ArrayRef { let validity = if nullable { diff --git a/encodings/pco/src/array.rs b/encodings/pco/src/array.rs index 627f0bc0751..c1a4347cd94 100644 --- a/encodings/pco/src/array.rs +++ b/encodings/pco/src/array.rs @@ -784,21 +784,25 @@ impl OperationsVTable for Pco { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::VALUES_PER_CHUNK; use crate::Pco; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_slice_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create a nullable array with some nulls let values = PrimitiveArray::new( buffer![10u32, 20, 30, 40, 50, 60], @@ -828,7 +832,7 @@ mod tests { #[test] fn test_decompress_bounds_initial_allocation() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::from_iter([42u32]); let pco = Pco::from_primitive(values.as_view(), 0, 128, &mut ctx)?; let mut data = pco.data().clone(); @@ -845,7 +849,7 @@ mod tests { #[test] fn test_validate_rejects_oversized_chunk() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::from_iter([42u32]); let pco = Pco::from_primitive(values.as_view(), 0, 128, &mut ctx)?; let mut data = pco.data().clone(); diff --git a/encodings/pco/src/compute/cast.rs b/encodings/pco/src/compute/cast.rs index 6ac0d7de3b9..af1d003d7f7 100644 --- a/encodings/pco/src/compute/cast.rs +++ b/encodings/pco/src/compute/cast.rs @@ -74,7 +74,7 @@ mod tests { use crate::Pco; - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_cast_pco_f32_to_f64() { diff --git a/encodings/pco/src/compute/mod.rs b/encodings/pco/src/compute/mod.rs index d86c3d4b0a3..0b79f0e5fd8 100644 --- a/encodings/pco/src/compute/mod.rs +++ b/encodings/pco/src/compute/mod.rs @@ -5,23 +5,27 @@ mod cast; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::consistency::test_array_consistency; + use vortex_session::VortexSession; use crate::Pco; use crate::PcoArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn pco_f32() -> PcoArray { let values = PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]); Pco::from_primitive( values.as_view(), 0, 128, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap() } @@ -32,7 +36,7 @@ mod tests { values.as_view(), 0, 128, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap() } @@ -43,7 +47,7 @@ mod tests { values.as_view(), 0, 128, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap() } @@ -54,7 +58,7 @@ mod tests { values.as_view(), 0, 128, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap() } @@ -65,7 +69,7 @@ mod tests { values.as_view(), 0, 128, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap() } @@ -76,7 +80,7 @@ mod tests { values.as_view(), 0, 128, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap() } @@ -87,7 +91,7 @@ mod tests { values.as_view(), 0, 128, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap() } @@ -98,7 +102,7 @@ mod tests { values.as_view(), 3, 128, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap() } @@ -113,9 +117,6 @@ mod tests { #[case::single(pco_single())] #[case::large(pco_large())] fn test_pco_consistency(#[case] array: PcoArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/pco/src/lib.rs b/encodings/pco/src/lib.rs index 70d71abf7d2..df6581ec1d1 100644 --- a/encodings/pco/src/lib.rs +++ b/encodings/pco/src/lib.rs @@ -13,8 +13,9 @@ //! //! ```rust //! use vortex_array::session::ArraySessionExt; +//! use vortex_session::VortexSession; //! -//! let session = vortex_array::array_session(); +//! let session = VortexSession::empty(); //! session.arrays().register(vortex_pco::Pco); //! ``` diff --git a/encodings/pco/src/probe/tests.rs b/encodings/pco/src/probe/tests.rs index f4c9740cf2c..c5386f1aa00 100644 --- a/encodings/pco/src/probe/tests.rs +++ b/encodings/pco/src/probe/tests.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayProbe; use vortex_array::ArrayRef; @@ -12,9 +14,12 @@ use vortex_array::assert_arrays_eq; use vortex_array::builders::builder_with_capacity_in; use vortex_array::validity::Validity; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::Pco; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// A one-off or retained probe over `array`, the retained one living in `retained`. fn probe_for<'a>( array: &'a ArrayRef, @@ -34,7 +39,7 @@ fn random_access( #[values(false, true)] nullable: bool, #[values(false, true)] sliced: bool, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = if nullable { PrimitiveArray::from_option_iter((0..4096i32).map(|i| (i % 7 != 0).then_some(i * 19))) } else { @@ -66,7 +71,7 @@ fn random_access( #[case(PrimitiveArray::from_iter([i64::MIN, -1, 0, i64::MAX]))] #[case(PrimitiveArray::from_iter([1.25f64, -2.5, 0.0, f64::INFINITY]))] fn preserves_physical_type(#[case] input: PrimitiveArray) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let encoded = Pco::from_primitive(input.as_view(), 3, 2, &mut ctx)?.into_array(); let mut probe = encoded.repeated_probe(); let mut actual = builder_with_capacity_in(input.dtype(), input.len(), ctx.allocator()); @@ -79,7 +84,7 @@ fn preserves_physical_type(#[case] input: PrimitiveArray) -> VortexResult<()> { #[test] fn all_null_access_returns_null() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = PrimitiveArray::new(vec![0i32; 128], Validity::AllInvalid); let encoded = Pco::from_primitive(input.as_view(), 3, 128, &mut ctx)?; let encoded = encoded.into_array(); @@ -90,7 +95,7 @@ fn all_null_access_returns_null() -> VortexResult<()> { #[test] fn probe_outlives_source_and_moves() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = PrimitiveArray::from_iter(0..4096u32); let array = Pco::from_primitive(input.as_view(), 3, 512, &mut ctx)?.into_array(); let probe = RepeatedArrayProbe::new(array.clone()); diff --git a/encodings/pco/src/tests.rs b/encodings/pco/src/tests.rs index 253d19c45d1..f57fb4d960a 100644 --- a/encodings/pco/src/tests.rs +++ b/encodings/pco/src/tests.rs @@ -31,7 +31,7 @@ use crate::PcoArrayExt; use crate::PcoData; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(Pco); session }); diff --git a/encodings/runend/benches/run_end_compress.rs b/encodings/runend/benches/run_end_compress.rs index c1935024d7a..a6e318ccc08 100644 --- a/encodings/runend/benches/run_end_compress.rs +++ b/encodings/runend/benches/run_end_compress.rs @@ -11,9 +11,16 @@ use mimalloc::MiMalloc; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::dtype::IntegerPType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_runend::RunEnd; @@ -27,11 +34,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_runend::initialize(&session); session }); diff --git a/encodings/runend/benches/run_end_decode.rs b/encodings/runend/benches/run_end_decode.rs index 3ca4544312d..1d1046d6528 100644 --- a/encodings/runend/benches/run_end_decode.rs +++ b/encodings/runend/benches/run_end_decode.rs @@ -9,8 +9,15 @@ use std::sync::LazyLock; use divan::Bencher; use mimalloc::MiMalloc; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_buffer::BufferMut; @@ -21,11 +28,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_runend::initialize(&session); session }); diff --git a/encodings/runend/benches/run_end_decode_primitive.rs b/encodings/runend/benches/run_end_decode_primitive.rs index a3eb60376c8..ff977bc305f 100644 --- a/encodings/runend/benches/run_end_decode_primitive.rs +++ b/encodings/runend/benches/run_end_decode_primitive.rs @@ -14,8 +14,15 @@ use rand::RngExt; use rand::SeedableRng; use rand::rngs::StdRng; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_buffer::Buffer; @@ -26,11 +33,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_runend::initialize(&session); session }); diff --git a/encodings/runend/benches/run_end_null_count.rs b/encodings/runend/benches/run_end_null_count.rs index af4d1e2fbb2..2c31e5e0780 100644 --- a/encodings/runend/benches/run_end_null_count.rs +++ b/encodings/runend/benches/run_end_null_count.rs @@ -12,7 +12,14 @@ use rand::SeedableRng; use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; use vortex_runend::RunEnd; use vortex_runend::RunEndArray; @@ -22,6 +29,7 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -54,7 +62,14 @@ const BENCH_ARGS: &[(usize, usize, f64)] = &[ ]; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_runend::initialize(&session); session }); diff --git a/encodings/runend/benches/run_end_sum.rs b/encodings/runend/benches/run_end_sum.rs index d5a7b338922..be600a3e08b 100644 --- a/encodings/runend/benches/run_end_sum.rs +++ b/encodings/runend/benches/run_end_sum.rs @@ -11,7 +11,14 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::aggregate_fn::fns::sum_v2::sum_v2; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_runend::RunEnd; use vortex_session::VortexSession; @@ -19,7 +26,14 @@ const LEN: usize = 2_048; const RUN_LENGTH: usize = 64; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_runend::initialize(&session); session }); diff --git a/encodings/runend/benches/run_end_take.rs b/encodings/runend/benches/run_end_take.rs index 910f43b98c9..0b451b0f034 100644 --- a/encodings/runend/benches/run_end_take.rs +++ b/encodings/runend/benches/run_end_take.rs @@ -15,7 +15,14 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_runend::RunEnd; @@ -25,11 +32,19 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_runend::initialize(&session); session }); diff --git a/encodings/runend/src/array.rs b/encodings/runend/src/array.rs index 0d8daa9b35b..787a5a02ecd 100644 --- a/encodings/runend/src/array.rs +++ b/encodings/runend/src/array.rs @@ -421,12 +421,13 @@ impl RunEndData { /// ``` /// # use vortex_array::arrays::BoolArray; /// # use vortex_array::IntoArray; + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; /// # use vortex_buffer::buffer; /// # use vortex_error::VortexResult; /// # use vortex_runend::RunEnd; /// # fn main() -> VortexResult<()> { - /// let session = vortex_array::array_session(); + /// let session = VortexSession::empty(); /// vortex_runend::initialize(&session); /// let mut ctx = session.create_execution_ctx(); /// let ends = buffer![2u8, 3u8].into_array(); @@ -597,7 +598,7 @@ mod tests { use crate::RunEnd; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/runend/src/compress.rs b/encodings/runend/src/compress.rs index 6d4ebd98c33..1a0b8978a48 100644 --- a/encodings/runend/src/compress.rs +++ b/encodings/runend/src/compress.rs @@ -445,7 +445,7 @@ mod tests { use crate::compress::runend_encode; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/runend/src/compute/cast.rs b/encodings/runend/src/compute/cast.rs index 2d81b017eeb..0619ae1614f 100644 --- a/encodings/runend/src/compute/cast.rs +++ b/encodings/runend/src/compute/cast.rs @@ -54,7 +54,7 @@ mod tests { use crate::RunEndArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/runend/src/compute/compare.rs b/encodings/runend/src/compute/compare.rs index f3facb1167a..00ce5a904e4 100644 --- a/encodings/runend/src/compute/compare.rs +++ b/encodings/runend/src/compute/compare.rs @@ -66,7 +66,7 @@ mod test { use crate::RunEndArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/runend/src/compute/mod.rs b/encodings/runend/src/compute/mod.rs index 296ab525952..4a542b2c517 100644 --- a/encodings/runend/src/compute/mod.rs +++ b/encodings/runend/src/compute/mod.rs @@ -28,7 +28,7 @@ mod tests { use crate::RunEndArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/runend/src/compute/take.rs b/encodings/runend/src/compute/take.rs index 54d1639cbc6..047a072e9ab 100644 --- a/encodings/runend/src/compute/take.rs +++ b/encodings/runend/src/compute/take.rs @@ -509,7 +509,7 @@ mod tests { use crate::RunEndArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/runend/src/compute/take_from.rs b/encodings/runend/src/compute/take_from.rs index 05d347a9264..15f8e040e1d 100644 --- a/encodings/runend/src/compute/take_from.rs +++ b/encodings/runend/src/compute/take_from.rs @@ -72,7 +72,7 @@ mod tests { use crate::compute::take_from::RunEndTakeFrom; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/runend/src/decompress_bool.rs b/encodings/runend/src/decompress_bool.rs index b74e5200e60..979a555c229 100644 --- a/encodings/runend/src/decompress_bool.rs +++ b/encodings/runend/src/decompress_bool.rs @@ -262,7 +262,7 @@ mod tests { use super::runend_decode_bools; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/runend/src/lib.rs b/encodings/runend/src/lib.rs index 98c661e6e36..7161d70af5a 100644 --- a/encodings/runend/src/lib.rs +++ b/encodings/runend/src/lib.rs @@ -82,7 +82,7 @@ mod tests { use crate::RunEndMetadata; pub static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/runend/src/ops.rs b/encodings/runend/src/ops.rs index 71761ec911d..c3eddf6f79e 100644 --- a/encodings/runend/src/ops.rs +++ b/encodings/runend/src/ops.rs @@ -92,7 +92,7 @@ mod tests { use crate::RunEnd; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sequence/src/array.rs b/encodings/sequence/src/array.rs index c15d3c1e8a0..f6ead2c5230 100644 --- a/encodings/sequence/src/array.rs +++ b/encodings/sequence/src/array.rs @@ -587,7 +587,7 @@ mod tests { use crate::Sequence; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sequence/src/compress.rs b/encodings/sequence/src/compress.rs index 7d229f6b4eb..6b3eeddea02 100644 --- a/encodings/sequence/src/compress.rs +++ b/encodings/sequence/src/compress.rs @@ -149,7 +149,7 @@ mod tests { use crate::sequence_encode; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sequence/src/compute/cast.rs b/encodings/sequence/src/compute/cast.rs index dff716b7fd4..8eca1229f3d 100644 --- a/encodings/sequence/src/compute/cast.rs +++ b/encodings/sequence/src/compute/cast.rs @@ -63,7 +63,7 @@ mod tests { use crate::SequenceArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sequence/src/compute/compare.rs b/encodings/sequence/src/compute/compare.rs index aa53cc44e00..e2f3a0186be 100644 --- a/encodings/sequence/src/compute/compare.rs +++ b/encodings/sequence/src/compute/compare.rs @@ -142,7 +142,7 @@ mod tests { use crate::Sequence; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sequence/src/compute/filter.rs b/encodings/sequence/src/compute/filter.rs index 52da57654f5..4920d4bbac2 100644 --- a/encodings/sequence/src/compute/filter.rs +++ b/encodings/sequence/src/compute/filter.rs @@ -53,20 +53,24 @@ fn filter_impl( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::compute::conformance::filter::LARGE_SIZE; use vortex_array::compute::conformance::filter::MEDIUM_SIZE; use vortex_array::compute::conformance::filter::test_filter_conformance; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; use vortex_array::scalar::PValue; + use vortex_session::VortexSession; use crate::Sequence; use crate::SequenceArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(Sequence::try_new_typed(0i32, 1, Nullability::NonNullable, 5).unwrap())] #[case(Sequence::try_new_typed(10i32, 2, Nullability::NonNullable, 5).unwrap())] @@ -93,9 +97,6 @@ mod tests { Nullability::NonNullable, MEDIUM_SIZE).unwrap() )] fn test_filter_sequence_conformance(#[case] array: SequenceArray) { - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/sequence/src/compute/list_contains.rs b/encodings/sequence/src/compute/list_contains.rs index 09d10a788da..ea966049ea4 100644 --- a/encodings/sequence/src/compute/list_contains.rs +++ b/encodings/sequence/src/compute/list_contains.rs @@ -109,7 +109,7 @@ mod tests { use crate::Sequence; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sequence/src/compute/min_max.rs b/encodings/sequence/src/compute/min_max.rs index ab6d4faf3ab..adb0781657f 100644 --- a/encodings/sequence/src/compute/min_max.rs +++ b/encodings/sequence/src/compute/min_max.rs @@ -95,7 +95,7 @@ mod tests { use crate::Sequence; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sequence/src/compute/mod.rs b/encodings/sequence/src/compute/mod.rs index 74539f302d5..340d08d1ca7 100644 --- a/encodings/sequence/src/compute/mod.rs +++ b/encodings/sequence/src/compute/mod.rs @@ -12,18 +12,22 @@ mod take; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::compute::conformance::consistency::test_array_consistency; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; use vortex_array::scalar::PValue; + use vortex_session::VortexSession; use crate::Sequence; use crate::SequenceArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] // Basic sequence arrays - A[i] = base + i * multiplier #[case::sequence_i32(Sequence::try_new_typed( @@ -110,9 +114,6 @@ mod tests { ).unwrap())] // Results in [1000, 1100, 1200, ..., 150900] fn test_sequence_consistency(#[case] array: SequenceArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/sequence/src/compute/take.rs b/encodings/sequence/src/compute/take.rs index f0055e95081..daf23a713ad 100644 --- a/encodings/sequence/src/compute/take.rs +++ b/encodings/sequence/src/compute/take.rs @@ -133,20 +133,24 @@ impl TakeExecute for Sequence { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::take::test_take_conformance; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; use vortex_array::scalar::PValue; + use vortex_session::VortexSession; use crate::Sequence; use crate::SequenceArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::basic_sequence(Sequence::try_new_typed( 0i32, @@ -218,10 +222,7 @@ mod test { 500 ).unwrap())] fn sequence_take_conformance(#[case] sequence: SequenceArray) { - test_take_conformance( - &sequence.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&sequence.into_array(), &mut SESSION.create_execution_ctx()); } #[test] @@ -232,7 +233,7 @@ mod test { let _array = array .take(indices.into_array()) .unwrap() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); } } diff --git a/encodings/sequence/src/model_tests.rs b/encodings/sequence/src/model_tests.rs index eb93c4199c3..9bfb4624bf0 100644 --- a/encodings/sequence/src/model_tests.rs +++ b/encodings/sequence/src/model_tests.rs @@ -3,6 +3,8 @@ //! Differential tests of sequence construction and its kernels against an exact `i128` model. +use std::sync::LazyLock; + use num_traits::Bounded; use num_traits::ToPrimitive; use vortex_array::ArrayRef; @@ -28,9 +30,16 @@ use vortex_array::scalar_fn::fns::operators::Operator; use vortex_error::VortexResult; use vortex_error::vortex_err; use vortex_mask::Mask; +use vortex_session::VortexSession; use crate::Sequence; +static SESSION: LazyLock = LazyLock::new(|| { + let session = VortexSession::empty(); + crate::initialize(&session); + session +}); + // Keep the `i128` oracle independent of the production code's 64-bit arithmetic. fn widen(value: PValue) -> Option { vortex_array::match_each_pvalue!( @@ -123,9 +132,7 @@ fn constant(value: i128, ptype: PType, len: usize) -> VortexResult { #[test] fn sequence_kernels_match_exact_model() -> VortexResult<()> { - let session = vortex_array::array_session(); - crate::initialize(&session); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut built = 0; for base in VALUES { diff --git a/encodings/sparse/benches/sparse_canonical.rs b/encodings/sparse/benches/sparse_canonical.rs index 381adcfe59f..ee7225b19fa 100644 --- a/encodings/sparse/benches/sparse_canonical.rs +++ b/encodings/sparse/benches/sparse_canonical.rs @@ -12,12 +12,19 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::ListViewArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::Nullability::NonNullable; use vortex_array::dtype::PType::I32; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_error::VortexExpect; @@ -28,11 +35,19 @@ use vortex_sparse::Sparse; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_sparse::initialize(&session); session }); diff --git a/encodings/sparse/benches/sparse_pushdown.rs b/encodings/sparse/benches/sparse_pushdown.rs index 0a28d634898..9045feb5ea1 100644 --- a/encodings/sparse/benches/sparse_pushdown.rs +++ b/encodings/sparse/benches/sparse_pushdown.rs @@ -25,14 +25,21 @@ use vortex_array::aggregate_fn::fns::is_constant::is_constant; use vortex_array::aggregate_fn::fns::min_max::min_max; use vortex_array::aggregate_fn::fns::null_count::null_count; use vortex_array::aggregate_fn::fns::sum::sum; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; use vortex_error::VortexExpect; use vortex_session::VortexSession; @@ -42,6 +49,7 @@ use vortex_sparse::Sparse; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -49,7 +57,14 @@ const LEN: usize = 1_000_000; /// Session with Sparse and its pushdown kernels registered. static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_sparse::initialize(&session); session }); diff --git a/encodings/sparse/src/canonical.rs b/encodings/sparse/src/canonical.rs index db9ae028414..7430228e931 100644 --- a/encodings/sparse/src/canonical.rs +++ b/encodings/sparse/src/canonical.rs @@ -914,7 +914,7 @@ mod test { use crate::Sparse; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sparse/src/compute/between.rs b/encodings/sparse/src/compute/between.rs index 35f5230d5ca..1a01958ac44 100644 --- a/encodings/sparse/src/compute/between.rs +++ b/encodings/sparse/src/compute/between.rs @@ -81,7 +81,7 @@ mod tests { use crate::initialize; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); diff --git a/encodings/sparse/src/compute/cast.rs b/encodings/sparse/src/compute/cast.rs index d59dcf8b143..88b07e0d9f4 100644 --- a/encodings/sparse/src/compute/cast.rs +++ b/encodings/sparse/src/compute/cast.rs @@ -55,7 +55,7 @@ mod tests { use crate::SparseArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sparse/src/compute/compare.rs b/encodings/sparse/src/compute/compare.rs index c3a83d164ee..ad1fad781eb 100644 --- a/encodings/sparse/src/compute/compare.rs +++ b/encodings/sparse/src/compute/compare.rs @@ -73,7 +73,7 @@ mod tests { use crate::initialize; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); diff --git a/encodings/sparse/src/compute/fill_null.rs b/encodings/sparse/src/compute/fill_null.rs index 8af5645aa10..1ae877068d2 100644 --- a/encodings/sparse/src/compute/fill_null.rs +++ b/encodings/sparse/src/compute/fill_null.rs @@ -62,7 +62,7 @@ mod tests { use crate::initialize; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); diff --git a/encodings/sparse/src/compute/filter.rs b/encodings/sparse/src/compute/filter.rs index 7a924155ff1..3c0dea3d773 100644 --- a/encodings/sparse/src/compute/filter.rs +++ b/encodings/sparse/src/compute/filter.rs @@ -57,7 +57,7 @@ mod tests { use crate::Sparse; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sparse/src/compute/is_constant.rs b/encodings/sparse/src/compute/is_constant.rs index 71e3130aea6..950865c9874 100644 --- a/encodings/sparse/src/compute/is_constant.rs +++ b/encodings/sparse/src/compute/is_constant.rs @@ -84,14 +84,14 @@ mod tests { /// Session with Sparse + its pushdown kernels. static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); /// Baseline session: Sparse registered but no pushdown kernels. static CANONICAL_SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(Sparse); session }); diff --git a/encodings/sparse/src/compute/like.rs b/encodings/sparse/src/compute/like.rs index e5a2333b190..a4cb23a41b3 100644 --- a/encodings/sparse/src/compute/like.rs +++ b/encodings/sparse/src/compute/like.rs @@ -81,7 +81,7 @@ mod tests { use crate::initialize; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); diff --git a/encodings/sparse/src/compute/min_max.rs b/encodings/sparse/src/compute/min_max.rs index 3e5037d32bc..a4a59a70277 100644 --- a/encodings/sparse/src/compute/min_max.rs +++ b/encodings/sparse/src/compute/min_max.rs @@ -78,13 +78,13 @@ mod tests { use crate::initialize; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); static CANONICAL_SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(Sparse); session }); diff --git a/encodings/sparse/src/compute/mod.rs b/encodings/sparse/src/compute/mod.rs index a47b1ac9431..6f142d60c85 100644 --- a/encodings/sparse/src/compute/mod.rs +++ b/encodings/sparse/src/compute/mod.rs @@ -24,7 +24,6 @@ mod tests { use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array; @@ -42,7 +41,7 @@ mod tests { use crate::SparseArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sparse/src/compute/nan_count.rs b/encodings/sparse/src/compute/nan_count.rs index 3d3d20a41e4..c891927dd57 100644 --- a/encodings/sparse/src/compute/nan_count.rs +++ b/encodings/sparse/src/compute/nan_count.rs @@ -86,13 +86,13 @@ mod tests { use crate::initialize; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); static CANONICAL_SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(Sparse); session }); diff --git a/encodings/sparse/src/compute/null_count.rs b/encodings/sparse/src/compute/null_count.rs index 205c00b528e..fa035f485d4 100644 --- a/encodings/sparse/src/compute/null_count.rs +++ b/encodings/sparse/src/compute/null_count.rs @@ -76,13 +76,13 @@ mod tests { use crate::initialize; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); static CANONICAL_SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(Sparse); session }); diff --git a/encodings/sparse/src/compute/sum.rs b/encodings/sparse/src/compute/sum.rs index 02c36ad36f3..c02e3e04e44 100644 --- a/encodings/sparse/src/compute/sum.rs +++ b/encodings/sparse/src/compute/sum.rs @@ -88,13 +88,13 @@ mod tests { use crate::initialize; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); static CANONICAL_SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(Sparse); session }); diff --git a/encodings/sparse/src/compute/take.rs b/encodings/sparse/src/compute/take.rs index c59c2c61533..33e65db6f83 100644 --- a/encodings/sparse/src/compute/take.rs +++ b/encodings/sparse/src/compute/take.rs @@ -75,7 +75,7 @@ mod test { use crate::SparseArray; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/sparse/src/lib.rs b/encodings/sparse/src/lib.rs index f1ec2ddc32c..55e5ed883e2 100644 --- a/encodings/sparse/src/lib.rs +++ b/encodings/sparse/src/lib.rs @@ -749,7 +749,7 @@ mod test { use crate::Sparse; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); initialize(&session); session }); diff --git a/encodings/sparse/src/ops.rs b/encodings/sparse/src/ops.rs index 06616b7e6f8..9b5088ab221 100644 --- a/encodings/sparse/src/ops.rs +++ b/encodings/sparse/src/ops.rs @@ -39,7 +39,7 @@ mod tests { use crate::Sparse; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/uuid/src/arrow.rs b/encodings/uuid/src/arrow.rs index 60b055b5097..55202147633 100644 --- a/encodings/uuid/src/arrow.rs +++ b/encodings/uuid/src/arrow.rs @@ -227,7 +227,6 @@ mod tests { use arrow_schema::Schema; use rstest::rstest; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::ListArray; use vortex_array::arrays::Struct; use vortex_array::arrays::StructArray; @@ -244,7 +243,7 @@ mod tests { /// A session with the UUID extension dtype and its Arrow plugins registered. fn uuid_session() -> VortexSession { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session } diff --git a/encodings/uuid/src/lib.rs b/encodings/uuid/src/lib.rs index 580e7763edc..b079120d88c 100644 --- a/encodings/uuid/src/lib.rs +++ b/encodings/uuid/src/lib.rs @@ -64,7 +64,6 @@ mod tests { use vortex_array::aggregate_fn::fns::min_max::MinMax; use vortex_array::aggregate_fn::fns::min_max::MinMaxResult; use vortex_array::aggregate_fn::session::AggregateFnSessionExt; - use vortex_array::array_session; use vortex_array::arrays::ExtensionArray; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::PrimitiveArray; @@ -81,7 +80,7 @@ mod tests { use super::*; fn uuid_session() -> VortexSession { - let session = array_session(); + let session = VortexSession::empty(); initialize(&session); session } diff --git a/encodings/zigzag/src/array.rs b/encodings/zigzag/src/array.rs index 2fdd9c90e0a..25fed1c159e 100644 --- a/encodings/zigzag/src/array.rs +++ b/encodings/zigzag/src/array.rs @@ -280,19 +280,23 @@ impl ValidityChild for ZigZag { #[cfg(test)] mod test { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::scalar::Scalar; use vortex_buffer::buffer; + use vortex_session::VortexSession; use super::*; use crate::zigzag_encode; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_compute_statistics() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = buffer![1i32, -5i32, 2, 3, 4, 5, 6, 7, 8, 9, 10] .into_array() .execute::(&mut ctx)?; diff --git a/encodings/zigzag/src/compress.rs b/encodings/zigzag/src/compress.rs index 4af8a7eef03..b7082d4514e 100644 --- a/encodings/zigzag/src/compress.rs +++ b/encodings/zigzag/src/compress.rs @@ -97,7 +97,7 @@ mod test { use crate::ZigZag; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/zigzag/src/compute/cast.rs b/encodings/zigzag/src/compute/cast.rs index 12064f432e8..1bd582f77f6 100644 --- a/encodings/zigzag/src/compute/cast.rs +++ b/encodings/zigzag/src/compute/cast.rs @@ -44,7 +44,7 @@ mod tests { use crate::zigzag_encode; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/zigzag/src/compute/mod.rs b/encodings/zigzag/src/compute/mod.rs index ed333cfcd1c..8e301febcc1 100644 --- a/encodings/zigzag/src/compute/mod.rs +++ b/encodings/zigzag/src/compute/mod.rs @@ -88,7 +88,7 @@ mod tests { use crate::zigzag_encode; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/encodings/zstd/src/array.rs b/encodings/zstd/src/array.rs index 5c413a5b2b8..78034a5fd83 100644 --- a/encodings/zstd/src/array.rs +++ b/encodings/zstd/src/array.rs @@ -1609,9 +1609,10 @@ impl OperationsVTable for Zstd { #[cfg(test)] #[expect(clippy::cast_possible_truncation)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::varbin::VarBinArrayExt as _; use vortex_array::builders::VarBinBuilder; use vortex_array::dtype::DType; @@ -1620,6 +1621,7 @@ mod tests { use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use super::DecompressedSlice; use super::ViewLen; @@ -1630,6 +1632,8 @@ mod tests { use super::zstd_value_offset; use crate::array::BinaryView; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Build a Zstd-style interleaved buffer: [u32-LE length][string bytes] repeated. fn make_interleaved(strings: &[&[u8]]) -> ByteBuffer { let mut buf = Vec::new(); @@ -1781,7 +1785,7 @@ mod tests { append_slice_to_varbin(&slice, &Mask::new_true(2), &mut builder)?; let appended = builder.finish_into_varbin(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(appended.bytes_at(0, &mut ctx).as_slice(), b"hello"); assert_eq!(appended.bytes_at(1, &mut ctx).as_slice(), b"world"); Ok(()) diff --git a/encodings/zstd/src/compute/cast.rs b/encodings/zstd/src/compute/cast.rs index e5f2bd424b0..f1bb4ebdcda 100644 --- a/encodings/zstd/src/compute/cast.rs +++ b/encodings/zstd/src/compute/cast.rs @@ -95,7 +95,7 @@ mod tests { use crate::Zstd; - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_cast_zstd_i32_to_i64() { diff --git a/encodings/zstd/src/compute/mod.rs b/encodings/zstd/src/compute/mod.rs index 75ef5273ca5..2a3da909f70 100644 --- a/encodings/zstd/src/compute/mod.rs +++ b/encodings/zstd/src/compute/mod.rs @@ -5,36 +5,40 @@ mod cast; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::compute::conformance::consistency::test_array_consistency; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::Zstd; use crate::ZstdArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn zstd_i32() -> ZstdArray { let values = PrimitiveArray::from_iter([100i32, 200, 300, 400, 500]); - Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap() + Zstd::from_primitive(&values, 0, 0, &mut SESSION.create_execution_ctx()).unwrap() } fn zstd_f64() -> ZstdArray { let values = PrimitiveArray::from_iter([1.1f64, 2.2, 3.3, 4.4, 5.5]); - Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap() + Zstd::from_primitive(&values, 0, 0, &mut SESSION.create_execution_ctx()).unwrap() } fn zstd_u32() -> ZstdArray { let values = PrimitiveArray::from_iter([10u32, 20, 30, 40, 50]); - Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap() + Zstd::from_primitive(&values, 0, 0, &mut SESSION.create_execution_ctx()).unwrap() } fn zstd_nullable_i64() -> ZstdArray { let values = PrimitiveArray::from_option_iter([Some(1000i64), None, Some(3000), Some(4000), None]); - Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap() + Zstd::from_primitive(&values, 0, 0, &mut SESSION.create_execution_ctx()).unwrap() } fn zstd_single() -> ZstdArray { @@ -42,7 +46,7 @@ mod tests { buffer![42i64], vortex_array::validity::Validity::NonNullable, ); - Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap() + Zstd::from_primitive(&values, 0, 0, &mut SESSION.create_execution_ctx()).unwrap() } fn zstd_large() -> ZstdArray { @@ -50,7 +54,7 @@ mod tests { buffer![0u32..1000], vortex_array::validity::Validity::NonNullable, ); - Zstd::from_primitive(&values, 3, 0, &mut array_session().create_execution_ctx()).unwrap() + Zstd::from_primitive(&values, 3, 0, &mut SESSION.create_execution_ctx()).unwrap() } fn zstd_all_same() -> ZstdArray { @@ -58,12 +62,12 @@ mod tests { buffer![42i32; 100], vortex_array::validity::Validity::NonNullable, ); - Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap() + Zstd::from_primitive(&values, 0, 0, &mut SESSION.create_execution_ctx()).unwrap() } fn zstd_negative() -> ZstdArray { let values = PrimitiveArray::from_iter([-100i32, -50, 0, 50, 100]); - Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap() + Zstd::from_primitive(&values, 0, 0, &mut SESSION.create_execution_ctx()).unwrap() } #[rstest] @@ -76,9 +80,6 @@ mod tests { #[case::all_same(zstd_all_same())] #[case::negative(zstd_negative())] fn test_zstd_consistency(#[case] array: ZstdArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/encodings/zstd/src/editions.rs b/encodings/zstd/src/editions.rs index 43f695a42e2..c621fa1c9ea 100644 --- a/encodings/zstd/src/editions.rs +++ b/encodings/zstd/src/editions.rs @@ -34,22 +34,29 @@ pub static DECLARATION: EditionDeclaration = EditionDeclaration { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_edition::EditionSessionExt; use vortex_edition::test_harness::validate_edition; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::*; + static SESSION: LazyLock = LazyLock::new(|| { + let session = VortexSession::empty(); + crate::initialize(&session); + session + }); + #[test] fn zstd_edition_is_valid() -> VortexResult<()> { - let session = vortex_array::array_session(); - crate::initialize(&session); - validate_edition(&session.editions(), &ZSTD_2026_02) + validate_edition(&SESSION.editions(), &ZSTD_2026_02) } #[test] fn initialize_does_not_enable_zstd_edition() { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); assert!( !session diff --git a/encodings/zstd/src/lib.rs b/encodings/zstd/src/lib.rs index 0c23695870d..e50f3cb1e21 100644 --- a/encodings/zstd/src/lib.rs +++ b/encodings/zstd/src/lib.rs @@ -16,8 +16,9 @@ //! //! ```rust //! use vortex_array::session::ArraySessionExt; +//! use vortex_session::VortexSession; //! -//! let session = vortex_array::array_session(); +//! let session = VortexSession::empty(); //! session.arrays().register(vortex_zstd::Zstd); //! ``` diff --git a/encodings/zstd/src/test.rs b/encodings/zstd/src/test.rs index 4a2e5344a82..7bcc0d6a59a 100644 --- a/encodings/zstd/src/test.rs +++ b/encodings/zstd/src/test.rs @@ -2,11 +2,12 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors #![expect(clippy::cast_possible_truncation)] +use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinViewArray; @@ -25,6 +26,7 @@ use vortex_buffer::BufferAllocatorRef; use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; use vortex_mask::Mask; +use vortex_session::VortexSession; use crate::Zstd; use crate::ZstdArray; @@ -32,9 +34,11 @@ use crate::ZstdData; use crate::ZstdFrameMetadata; use crate::ZstdMetadata; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_zstd_compress_decompress() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let data: Vec = (0..200).collect(); let array = PrimitiveArray::from_iter(data.clone()); @@ -69,7 +73,7 @@ fn test_zstd_compress_decompress() { #[test] fn test_zstd_empty() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let data: Vec = vec![]; let array = PrimitiveArray::new( data.iter().cloned().collect::>(), @@ -83,7 +87,7 @@ fn test_zstd_empty() { #[test] fn test_zstd_with_validity_and_multi_frame() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let data: Vec = (0..200).collect(); let mut validity: Vec = vec![false; 200]; validity[3] = true; @@ -137,7 +141,7 @@ fn test_zstd_with_validity_and_multi_frame() { #[test] fn test_zstd_with_dict() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let data: Vec = (0..200).collect(); let array = PrimitiveArray::new( data.iter().cloned().collect::>(), @@ -159,7 +163,7 @@ fn test_zstd_with_dict() { #[test] fn test_validity_vtable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mask_bools = vec![false, true, true, false, true]; let array = PrimitiveArray::new( (0..5).collect::>(), @@ -170,7 +174,7 @@ fn test_validity_vtable() { assert_eq!( arr.validity() .unwrap() - .execute_mask(arr.len(), &mut array_session().create_execution_ctx()) + .execute_mask(arr.len(), &mut SESSION.create_execution_ctx()) .unwrap(), Mask::from_iter(mask_bools) ); @@ -179,7 +183,7 @@ fn test_validity_vtable() { sliced .validity() .unwrap() - .execute_mask(sliced.len(), &mut array_session().create_execution_ctx()) + .execute_mask(sliced.len(), &mut SESSION.create_execution_ctx()) .unwrap(), Mask::from_iter(vec![true, true, false]) ); @@ -187,7 +191,7 @@ fn test_validity_vtable() { #[test] fn test_zstd_var_bin_view() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let data: [Option<&'static [u8]>; 5] = [ Some(b"foo"), Some(b"bar"), @@ -216,7 +220,7 @@ fn test_zstd_var_bin_view() { #[test] fn test_zstd_append_to_primitive_builder() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::from_option_iter([Some(1_i32), None, Some(3), Some(4), Some(5)]); let compressed = Zstd::from_primitive(&array, 0, 3, &mut ctx)?.slice(1..4)?; let mut builder = builder_with_capacity_in( @@ -237,7 +241,7 @@ fn test_zstd_append_to_offset_builder( )] dtype: DType, ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter( [ Some(b"foo".as_slice()), @@ -272,7 +276,7 @@ fn test_zstd_append_to_offset_builder( /// requested region may reach it — otherwise the finished array retains the whole frames. #[test] fn test_zstd_append_to_view_builder_keeps_only_the_sliced_bytes() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Long enough that the values live in the data buffers rather than inline in the views. let values = (0..12) .map(|i| format!("value number {i} padded well past the inline limit")) @@ -353,7 +357,7 @@ fn corrupt_var_bin_view_metadata( fn test_zstd_rejects_corrupt_frame_metadata( #[case] corrupt: fn(&mut ZstdMetadata), ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let (_, compressed) = corrupt_var_bin_view_metadata(3, corrupt, &mut ctx)?; assert!(Zstd::decompress(&compressed, &mut ctx).is_err()); @@ -375,7 +379,7 @@ fn test_zstd_rejects_corrupt_frame_metadata( /// nothing but a length prefix has to error from every read path, not read back as an empty value. #[test] fn test_zstd_rejects_a_frame_ending_in_a_dangling_length_prefix() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut values = Vec::new(); values.extend_from_slice(&3u32.to_le_bytes()); values.extend_from_slice(b"cat"); @@ -415,7 +419,7 @@ fn test_zstd_rejects_a_frame_ending_in_a_dangling_length_prefix() -> VortexResul /// holds every stored value, so those arrays still read back. #[test] fn test_zstd_reads_legacy_single_frame_var_bin_metadata() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let (array, compressed) = corrupt_var_bin_view_metadata(0, |metadata| metadata.frames[0].n_values = 0, &mut ctx)?; @@ -432,7 +436,7 @@ fn test_zstd_reads_legacy_single_frame_var_bin_metadata() -> VortexResult<()> { /// stays exact across frames. #[test] fn test_zstd_reads_legacy_primitive_frame_metadata() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::from_iter(0..200_i32); let mut data = ZstdData::from_primitive(&array, 3, 30, &mut ctx)?; for frame in &mut data.metadata.frames { @@ -453,7 +457,7 @@ fn test_zstd_reads_legacy_primitive_frame_metadata() -> VortexResult<()> { /// the buffer alignment when compressing primitive arrays. #[test] fn test_zstd_frame_start_buffer_alignment() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let data = vec![0u8; 2]; let aligned_buffer = Buffer::copy_from_aligned(&data, Alignment::new(8)); // u8 array now has a 8-byte alignment. @@ -465,7 +469,7 @@ fn test_zstd_frame_start_buffer_alignment() { #[test] fn test_zstd_rejects_mismatched_frame_content_size() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let compressed = Zstd::from_primitive(&PrimitiveArray::from_iter([1_i32, 2, 3]), 0, 0, &mut ctx).unwrap(); let mut data = compressed.data().clone(); diff --git a/encodings/zstd/src/zstd_buffers.rs b/encodings/zstd/src/zstd_buffers.rs index c7f6aa16bf9..c7478e79c0b 100644 --- a/encodings/zstd/src/zstd_buffers.rs +++ b/encodings/zstd/src/zstd_buffers.rs @@ -663,12 +663,13 @@ impl ValidityVTable for ZstdBuffers { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayContext; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::assert_arrays_eq; @@ -681,10 +682,13 @@ mod tests { use vortex_buffer::ByteBufferMut; use vortex_error::VortexExpect; use vortex_error::VortexResult; + use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use super::*; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn make_primitive_array() -> ArrayRef { PrimitiveArray::from_iter(0i32..100).into_array() } @@ -725,12 +729,12 @@ mod tests { #[case::empty_primitive(make_empty_primitive_array())] #[case::inlined_varbinview(make_inlined_varbinview_array())] fn test_roundtrip(#[case] input: ArrayRef) -> VortexResult<()> { - let compressed = ZstdBuffers::compress(&input, 3, &array_session())?; + let compressed = ZstdBuffers::compress(&input, 3, &SESSION)?; assert_eq!(compressed.len(), input.len()); assert_eq!(compressed.dtype(), input.dtype()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(compressed, input, &mut ctx); Ok(()) @@ -744,7 +748,7 @@ mod tests { #[case::empty_primitive(make_empty_primitive_array())] #[case::inlined_varbinview(make_inlined_varbinview_array())] fn test_serde_roundtrip(#[case] input: ArrayRef) -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); session.arrays().register(ZstdBuffers); let compressed = ZstdBuffers::compress(&input, 3, &session)?.into_array(); @@ -772,7 +776,7 @@ mod tests { let input = make_primitive_array(); input.statistics().set(Stat::Min, Precision::exact(0i32)); - let compressed = ZstdBuffers::compress(&input, 3, &array_session())?; + let compressed = ZstdBuffers::compress(&input, 3, &SESSION)?; assert_eq!( compressed.statistics().get(Stat::Min), @@ -783,7 +787,7 @@ mod tests { #[test] fn test_rejects_mismatched_frame_content_size_before_output_allocation() -> VortexResult<()> { - let compressed = ZstdBuffers::compress(&make_primitive_array(), 3, &array_session())?; + let compressed = ZstdBuffers::compress(&make_primitive_array(), 3, &SESSION)?; let mut data = compressed.data().clone(); data.uncompressed_sizes[0] = 16 * 1024 * 1024 * 1024; @@ -802,9 +806,9 @@ mod tests { #[test] fn test_validity_delegates_for_nullable_input() -> VortexResult<()> { let input = make_nullable_primitive_array(); - let compressed = ZstdBuffers::compress(&input, 3, &array_session())?.into_array(); + let compressed = ZstdBuffers::compress(&input, 3, &SESSION)?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(compressed.all_valid(&mut ctx)?, input.all_valid(&mut ctx)?); assert_eq!( compressed.all_invalid(&mut ctx)?, @@ -823,8 +827,7 @@ mod tests { #[test] fn test_validity_shares_inner_child() -> VortexResult<()> { - let compressed = - ZstdBuffers::compress(&make_nullable_primitive_array(), 3, &array_session())?; + let compressed = ZstdBuffers::compress(&make_nullable_primitive_array(), 3, &SESSION)?; assert_eq!( compressed.slots().len(), @@ -838,20 +841,20 @@ mod tests { fn test_all_invalid_validity_uses_extra_slot() -> VortexResult<()> { let input = PrimitiveArray::new(vortex_buffer::buffer![1i32, 2, 3], Validity::AllInvalid) .into_array(); - let compressed = ZstdBuffers::compress(&input, 3, &array_session())?; + let compressed = ZstdBuffers::compress(&input, 3, &SESSION)?; let inner_child_count = compressed.data().inner_child_count; assert_eq!(compressed.slots().len(), inner_child_count + 1); assert_eq!(compressed.data().validity_slot, Some(inner_child_count)); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(compressed.into_array().all_invalid(&mut ctx)?); Ok(()) } #[test] fn test_deserialize_without_lifted_validity() -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); let input = make_nullable_primitive_array(); let compressed = ZstdBuffers::compress(&input, 3, &session)?; diff --git a/fuzz/src/array/fill_null.rs b/fuzz/src/array/fill_null.rs index 83822791da5..69e10482658 100644 --- a/fuzz/src/array/fill_null.rs +++ b/fuzz/src/array/fill_null.rs @@ -306,7 +306,6 @@ mod tests { use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::PrimitiveArray; @@ -320,19 +319,20 @@ mod tests { use vortex_array::scalar::Scalar; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; + use vortex_session::VortexSession; use super::fill_null_canonical_array; fn canonical(array: impl IntoArray) -> Canonical { array .into_array() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut VortexSession::empty().create_execution_ctx()) .unwrap() } #[test] fn test_fill_null_primitive() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, Some(5)]); let fill_value = Scalar::from(42i32); @@ -344,7 +344,7 @@ mod tests { #[test] fn test_fill_null_bool() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let data_buffer = BitBuffer::from(vec![true, false, false, false]); let validity_buffer = BitBuffer::from(vec![true, false, true, false]); let array = BoolArray::new(data_buffer, Validity::from(validity_buffer)); @@ -358,7 +358,7 @@ mod tests { #[test] fn test_fill_null_string() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = VarBinViewArray::from_iter( [Some("hello"), None, Some("world")].iter().copied(), DType::Utf8(Nullability::Nullable), @@ -373,7 +373,7 @@ mod tests { #[test] fn test_fill_null_all_invalid() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = PrimitiveArray::from_option_iter([None::, None, None]); let fill_value = Scalar::from(100i32); @@ -385,7 +385,7 @@ mod tests { #[test] fn test_fill_null_no_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = PrimitiveArray::from_iter([1i32, 2, 3]); let fill_value = Scalar::from(42i32); @@ -398,7 +398,7 @@ mod tests { #[test] #[should_panic(expected = "fill value conversion should succeed in fuzz test")] fn test_fill_null_with_null_value_errors() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]); let fill_value = Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable)); @@ -411,7 +411,7 @@ mod tests { #[test] fn test_fill_null_decimal_i32() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = DecimalArray::from_option_iter( [Some(100i32), None, Some(300i32), None, Some(500i32)], DecimalDType::new(10, 2), @@ -433,7 +433,7 @@ mod tests { #[test] fn test_fill_null_decimal_i64() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = DecimalArray::from_option_iter( [Some(1000i64), None, Some(3000i64)], DecimalDType::new(15, 3), @@ -453,7 +453,7 @@ mod tests { #[test] fn test_fill_null_decimal_i128() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = DecimalArray::from_option_iter( [Some(10000i128), None, Some(30000i128), None], DecimalDType::new(20, 4), @@ -475,7 +475,7 @@ mod tests { #[test] fn test_fill_null_decimal_all_invalid() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = DecimalArray::from_option_iter([None::, None, None], DecimalDType::new(10, 2)); let fill_value = Scalar::decimal( @@ -492,7 +492,7 @@ mod tests { #[test] fn test_fill_null_decimal_no_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = DecimalArray::from_option_iter( [Some(100i32), Some(200i32), Some(300i32)], DecimalDType::new(10, 2), diff --git a/fuzz/src/array/mask.rs b/fuzz/src/array/mask.rs index 73a14f3ca12..c20f024448a 100644 --- a/fuzz/src/array/mask.rs +++ b/fuzz/src/array/mask.rs @@ -177,7 +177,6 @@ mod tests { use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::FixedSizeListArray; @@ -192,6 +191,7 @@ mod tests { use vortex_array::dtype::Nullability; use vortex_array::validity::Validity; use vortex_mask::Mask; + use vortex_session::VortexSession; use super::mask_canonical_array; @@ -201,7 +201,7 @@ mod tests { #[test] fn test_mask_null_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = NullArray::new(5); let mask = Mask::from_iter([true, false, true, false, true]); @@ -212,7 +212,7 @@ mod tests { #[test] fn test_mask_bool_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = BoolArray::from_iter([true, false, true, false, true]); let mask = Mask::from_iter([false, true, true, false, true]); @@ -224,7 +224,7 @@ mod tests { #[test] fn test_mask_primitive_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]); let mask = Mask::from_iter([true, false, true, false, true]); @@ -236,7 +236,7 @@ mod tests { #[test] fn test_mask_primitive_array_with_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), None]); let mask = Mask::from_iter([false, true, true, false, true]); @@ -248,7 +248,7 @@ mod tests { #[test] fn test_mask_decimal_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let array = DecimalArray::from_option_iter( [Some(1i128), Some(2), Some(3), Some(4), Some(5)], @@ -265,7 +265,7 @@ mod tests { #[test] fn test_mask_varbinview_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["one", "two", "three", "four", "five"]); let mask = Mask::from_iter([false, true, false, true, false]); @@ -278,7 +278,7 @@ mod tests { #[test] fn test_mask_list_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let elements = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6]).into_array(); let offsets = PrimitiveArray::from_iter([0i32, 2, 4]).into_array(); let sizes = PrimitiveArray::from_iter([2i32, 2, 2]).into_array(); @@ -304,7 +304,7 @@ mod tests { #[test] fn test_mask_fixed_size_list_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let elements = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6]).into_array(); let array = FixedSizeListArray::try_new(elements, 2, Nullability::NonNullable.into(), 3).unwrap(); @@ -325,7 +325,7 @@ mod tests { #[test] fn test_mask_struct_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let field1 = PrimitiveArray::from_iter([1i32, 2, 3]).into_array(); let field2 = PrimitiveArray::from_iter([4i32, 5, 6]).into_array(); let fields = vec![field1, field2]; @@ -357,7 +357,7 @@ mod tests { #[test] fn test_mask_all_false() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]); let mask = Mask::AllFalse(5); @@ -369,7 +369,7 @@ mod tests { #[test] fn test_mask_all_true() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]); let mask = Mask::AllTrue(5); @@ -382,7 +382,7 @@ mod tests { #[test] fn test_mask_empty_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let array = PrimitiveArray::from_iter(Vec::::new()); for mask in [Mask::AllFalse(0), Mask::AllTrue(0)] { let result = diff --git a/fuzz/src/fsst_like.rs b/fuzz/src/fsst_like.rs index 92f53cae258..0cd9b4c0cae 100644 --- a/fuzz/src/fsst_like.rs +++ b/fuzz/src/fsst_like.rs @@ -31,7 +31,7 @@ use crate::error::Backtrace; use crate::error::VortexFuzzError; use crate::error::VortexFuzzResult; -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); /// A random string from a small alphabet (`a..=h`) with bounded length. #[derive(Debug)] diff --git a/vortex-array/benches/aggregate_grouped.rs b/vortex-array/benches/aggregate_grouped.rs index 188e34718f0..5515426cfcc 100644 --- a/vortex-array/benches/aggregate_grouped.rs +++ b/vortex-array/benches/aggregate_grouped.rs @@ -22,10 +22,17 @@ use vortex_array::aggregate_fn::NumericalAggregateOpts; use vortex_array::aggregate_fn::fns::count::Count; use vortex_array::aggregate_fn::fns::sum::Sum; use vortex_array::aggregate_fn::fns::sum_v2::SumV2; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ListViewArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::dtype::DType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -38,7 +45,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const GROUP_COUNT: usize = 128; const GROUP_SIZE_SEED: u64 = 42; diff --git a/vortex-array/benches/aggregate_max.rs b/vortex-array/benches/aggregate_max.rs index 2211446d081..2f27798b77d 100644 --- a/vortex-array/benches/aggregate_max.rs +++ b/vortex-array/benches/aggregate_max.rs @@ -10,11 +10,17 @@ use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::aggregate_fn::NumericalAggregateOpts; use vortex_array::aggregate_fn::fns::min_max::min_max; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -28,7 +34,16 @@ fn main() { // Sized to keep the CodSpeed simulation under 1ms per benchmark. const N: usize = 15_000; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[divan::bench] fn max_i32(bencher: Bencher) { diff --git a/vortex-array/benches/aggregate_sum.rs b/vortex-array/benches/aggregate_sum.rs index 7213745e5bb..8d2329412db 100644 --- a/vortex-array/benches/aggregate_sum.rs +++ b/vortex-array/benches/aggregate_sum.rs @@ -9,9 +9,15 @@ use rand::prelude::*; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::aggregate_fn::fns::sum_v2::sum_v2; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::stats::Stat; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -25,7 +31,16 @@ fn main() { // Sized to keep the CodSpeed simulation under 1ms per benchmark. const N: usize = 15_000; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[divan::bench] fn sum_i32(bencher: Bencher) { diff --git a/vortex-array/benches/binary_ops.rs b/vortex-array/benches/binary_ops.rs index 865dd01fa8c..cddd5a730e7 100644 --- a/vortex-array/benches/binary_ops.rs +++ b/vortex-array/benches/binary_ops.rs @@ -28,14 +28,20 @@ use vortex_array::ArrayRef; use vortex_array::Executable; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DecimalDType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -46,7 +52,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Sized to keep CodSpeed simulation under 1ms per benchmark. const LEN: usize = 4_096; diff --git a/vortex-array/benches/bool_zip.rs b/vortex-array/benches/bool_zip.rs index 1012cd7207e..0bdc125defc 100644 --- a/vortex-array/benches/bool_zip.rs +++ b/vortex-array/benches/bool_zip.rs @@ -11,9 +11,15 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::builtins::ArrayBuiltins; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_mask::Mask; use vortex_session::VortexSession; @@ -25,7 +31,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const LEN: usize = 65_536; diff --git a/vortex-array/benches/cast_decimal.rs b/vortex-array/benches/cast_decimal.rs index c1c32147059..587bf6d6901 100644 --- a/vortex-array/benches/cast_decimal.rs +++ b/vortex-array/benches/cast_decimal.rs @@ -20,11 +20,18 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::DecimalArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DType; use vortex_array::dtype::DecimalDType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BufferMut; use vortex_session::VortexSession; @@ -36,6 +43,7 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -43,7 +51,16 @@ fn main() { // and to keep the CodSpeed simulation under 1ms per benchmark. const SIZES: &[usize] = &[16_384]; -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Builds an `i64`-backed `Decimal(precision, scale)` array of `n` values that all fit in /// precision 10, optionally with ~50% nulls. diff --git a/vortex-array/benches/cast_primitive.rs b/vortex-array/benches/cast_primitive.rs index 7d0a96ce42b..2d59c03986b 100644 --- a/vortex-array/benches/cast_primitive.rs +++ b/vortex-array/benches/cast_primitive.rs @@ -11,14 +11,20 @@ use rand::prelude::*; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DType; use vortex_array::dtype::DecimalDType; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::stats::Stat; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -34,7 +40,16 @@ fn main() { // to keep the CodSpeed simulation under 1ms per benchmark. const SIZES: &[usize] = &[8_192]; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[divan::bench(args = SIZES)] fn cast_u16_to_u32(bencher: Bencher, n: usize) { diff --git a/vortex-array/benches/chunk_array_builder.rs b/vortex-array/benches/chunk_array_builder.rs index 954c6a677e1..4ea4a721d1c 100644 --- a/vortex-array/benches/chunk_array_builder.rs +++ b/vortex-array/benches/chunk_array_builder.rs @@ -12,7 +12,7 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ConstantArray; @@ -21,6 +21,12 @@ use vortex_array::builders::VarBinBuilder; use vortex_array::builders::VarBinViewBuilder; use vortex_array::builders::builder_with_capacity_in; use vortex_array::dtype::DType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_error::VortexExpect; use vortex_session::VortexSession; @@ -40,7 +46,16 @@ const BENCH_ARGS: &[(usize, usize)] = &[ (1000, 10), ]; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[divan::bench(args = BENCH_ARGS)] fn chunked_bool_canonical_into(bencher: Bencher, (len, chunk_count): (usize, usize)) { diff --git a/vortex-array/benches/chunked_dict_builder.rs b/vortex-array/benches/chunked_dict_builder.rs index af0afb45287..65e50e6730d 100644 --- a/vortex-array/benches/chunked_dict_builder.rs +++ b/vortex-array/benches/chunked_dict_builder.rs @@ -9,9 +9,16 @@ use rand::distr::Distribution; use rand::distr::StandardUniform; use vortex_array::Canonical; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::dict_test::gen_dict_primitive_chunks; use vortex_array::builders::builder_with_capacity_in; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_error::VortexExpect; use vortex_session::VortexSession; @@ -23,7 +30,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); // Chunk counts sized to keep CodSpeed simulation under 1ms per benchmark. const BENCH_ARGS: &[(usize, usize, usize)] = &[ diff --git a/vortex-array/benches/chunked_fsl_canonicalize.rs b/vortex-array/benches/chunked_fsl_canonicalize.rs index 5c980b5dd58..544154edc41 100644 --- a/vortex-array/benches/chunked_fsl_canonicalize.rs +++ b/vortex-array/benches/chunked_fsl_canonicalize.rs @@ -17,9 +17,15 @@ use mimalloc::MiMalloc; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::FixedSizeListArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -32,7 +38,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Number of lists in each chunk. const LISTS_PER_CHUNK: usize = 1_000; diff --git a/vortex-array/benches/compare.rs b/vortex-array/benches/compare.rs index 8e040ce1b91..71131602d69 100644 --- a/vortex-array/benches/compare.rs +++ b/vortex-array/benches/compare.rs @@ -22,6 +22,8 @@ #![expect(clippy::unwrap_used)] +use std::sync::LazyLock; + use divan::Bencher; use divan::counter::ItemsCount; use mimalloc::MiMalloc; @@ -33,6 +35,7 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::DecimalArray; @@ -41,15 +44,34 @@ use vortex_array::arrays::StructArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DecimalDType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; +use vortex_session::VortexSession; + +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -57,12 +79,11 @@ fn main() { const ARRAY_SIZE: usize = 8_192; fn bench_compare(bencher: Bencher, lhs: ArrayRef, rhs: ArrayRef, op: Operator) { - let session = vortex_array::array_session(); let len = lhs.len(); bencher .counter(ItemsCount::new(len)) - .with_inputs(|| (&lhs, &rhs, session.create_execution_ctx())) + .with_inputs(|| (&lhs, &rhs, SESSION.create_execution_ctx())) .bench_refs(|input| { input .0 diff --git a/vortex-array/benches/compare_sorted.rs b/vortex-array/benches/compare_sorted.rs index 2de0a09b5df..bd04ca99aad 100644 --- a/vortex-array/benches/compare_sorted.rs +++ b/vortex-array/benches/compare_sorted.rs @@ -6,6 +6,8 @@ #![expect(clippy::unwrap_used)] +use std::sync::LazyLock; + use divan::Bencher; use divan::counter::ItemsCount; use mimalloc::MiMalloc; @@ -13,24 +15,44 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::ExtensionArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::stats::Precision; use vortex_array::expr::stats::Stat; use vortex_array::extension::datetime::TimeUnit; use vortex_array::extension::datetime::Timestamp; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; use vortex_array::scalar::ScalarValue; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; +use vortex_session::VortexSession; + +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -42,11 +64,10 @@ fn bench_compare(bencher: Bencher, lhs: ArrayRef, constant: Scalar, op: Operator lhs.statistics() .set(Stat::IsSorted, Precision::exact(ScalarValue::from(true))); } - let session = vortex_array::array_session(); let rhs = ConstantArray::new(constant, lhs.len()).into_array(); bencher .counter(ItemsCount::new(lhs.len())) - .with_inputs(|| (&lhs, &rhs, session.create_execution_ctx())) + .with_inputs(|| (&lhs, &rhs, SESSION.create_execution_ctx())) .bench_refs(|input| { input .0 diff --git a/vortex-array/benches/dict_compare.rs b/vortex-array/benches/dict_compare.rs index f40cb061d78..fe5336e4b57 100644 --- a/vortex-array/benches/dict_compare.rs +++ b/vortex-array/benches/dict_compare.rs @@ -10,7 +10,7 @@ use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::VarBinArray; use vortex_array::arrays::VarBinViewArray; @@ -19,10 +19,16 @@ use vortex_array::arrays::dict_test::gen_varbin_words; use vortex_array::arrays::varbin::VarBinArrayExt; use vortex_array::builders::dict::dict_encode; use vortex_array::builtins::ArrayBuiltins; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::eq; use vortex_array::expr::lit; use vortex_array::expr::root; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -33,7 +39,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const LENGTH_AND_UNIQUE_VALUES: &[(usize, usize)] = &[ // length, unique_values diff --git a/vortex-array/benches/dict_compress.rs b/vortex-array/benches/dict_compress.rs index e8b1b0ec8c5..a590df8bf17 100644 --- a/vortex-array/benches/dict_compress.rs +++ b/vortex-array/benches/dict_compress.rs @@ -12,13 +12,19 @@ use rand::distr::StandardUniform; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::VarBinArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::arrays::dict_test::gen_primitive_for_dict; use vortex_array::arrays::dict_test::gen_varbin_words; use vortex_array::builders::dict::dict_encode; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -44,7 +50,16 @@ const BENCH_ARGS: &[(usize, usize)] = &[ (2_000, 512), ]; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[divan::bench(types = [u8, f32, i64], args = BENCH_ARGS)] fn encode_primitives(bencher: Bencher, (len, unique_values): (usize, usize)) diff --git a/vortex-array/benches/dict_mask.rs b/vortex-array/benches/dict_mask.rs index 0497b3a0068..26fcaa771a0 100644 --- a/vortex-array/benches/dict_mask.rs +++ b/vortex-array/benches/dict_mask.rs @@ -3,6 +3,8 @@ #![expect(clippy::unwrap_used)] +use std::sync::LazyLock; + use divan::Bencher; use mimalloc::MiMalloc; use rand::RngExt; @@ -11,15 +13,35 @@ use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::DictArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::builtins::ArrayBuiltins; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_mask::Mask; +use vortex_session::VortexSession; + +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -64,9 +86,8 @@ fn bench_dict_mask(bencher: Bencher, (fraction_valid, fraction_masked): (f64, f6 let values = PrimitiveArray::from_option_iter([None, Some(42i32)]).into_array(); let array = DictArray::try_new(codes, values).unwrap().into_array(); let filter_mask = filter_mask(len, fraction_masked, &mut rng); - let session = vortex_array::array_session(); bencher - .with_inputs(|| (&array, &filter_mask, session.create_execution_ctx())) + .with_inputs(|| (&array, &filter_mask, SESSION.create_execution_ctx())) .bench_refs(|(array, filter_mask, ctx)| { array .clone() diff --git a/vortex-array/benches/dict_unreferenced_mask.rs b/vortex-array/benches/dict_unreferenced_mask.rs index aa342e587ce..62d20ff5284 100644 --- a/vortex-array/benches/dict_unreferenced_mask.rs +++ b/vortex-array/benches/dict_unreferenced_mask.rs @@ -12,18 +12,34 @@ use rand::SeedableRng; use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::DictArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::dict::DictArrayExt; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-array/benches/expr/case_when_bench.rs b/vortex-array/benches/expr/case_when_bench.rs index 5cacd1a76bd..50335f87904 100644 --- a/vortex-array/benches/expr/case_when_bench.rs +++ b/vortex-array/benches/expr/case_when_bench.rs @@ -12,7 +12,7 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::DecimalArray; @@ -21,6 +21,7 @@ use vortex_array::arrays::StructArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DecimalDType; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::case_when; use vortex_array::expr::case_when_no_else; use vortex_array::expr::eq; @@ -30,11 +31,16 @@ use vortex_array::expr::lit; use vortex_array::expr::lt; use vortex_array::expr::nested_case_when; use vortex_array::expr::root; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; use vortex_array::scalar_fn::ScalarFnVTableExt; use vortex_array::scalar_fn::fns::case_when::CaseWhen; use vortex_array::scalar_fn::fns::case_when::CaseWhenOptions; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -42,7 +48,16 @@ use vortex_session::VortexSession; #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn main() { LazyLock::force(&SESSION); diff --git a/vortex-array/benches/filter_bool.rs b/vortex-array/benches/filter_bool.rs index 27a419e8f66..e3314d8b868 100644 --- a/vortex-array/benches/filter_bool.rs +++ b/vortex-array/benches/filter_bool.rs @@ -19,8 +19,14 @@ use rand::prelude::*; use rand_distr::Zipf; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::BitBuffer; use vortex_mask::Mask; use vortex_session::VortexSession; @@ -33,7 +39,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const SIZES: &[usize] = &[1_000, 10_000, 100_000, 250_000]; const DENSITY_SWEEP_SIZE: usize = 100_000; diff --git a/vortex-array/benches/filter_fixed_width.rs b/vortex-array/benches/filter_fixed_width.rs index 477d09f293d..d92b3e3c52e 100644 --- a/vortex-array/benches/filter_fixed_width.rs +++ b/vortex-array/benches/filter_fixed_width.rs @@ -20,11 +20,17 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::DecimalDType; use vortex_array::dtype::i256; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::BitBuffer; use vortex_mask::Mask; use vortex_session::VortexSession; @@ -37,7 +43,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Bytes of values per input array. /// diff --git a/vortex-array/benches/filter_fsl.rs b/vortex-array/benches/filter_fsl.rs index de51d3c5f26..4b15c9c066b 100644 --- a/vortex-array/benches/filter_fsl.rs +++ b/vortex-array/benches/filter_fsl.rs @@ -16,9 +16,15 @@ use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_mask::Mask; @@ -32,7 +38,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const NUM_ELEMENTS: usize = 1 << 17; diff --git a/vortex-array/benches/filter_list.rs b/vortex-array/benches/filter_list.rs index e2d27e08e0f..a09dd08cf53 100644 --- a/vortex-array/benches/filter_list.rs +++ b/vortex-array/benches/filter_list.rs @@ -13,9 +13,15 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ListArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_mask::Mask; @@ -29,7 +35,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const LIST_LENGTH: usize = 512; const N_ELEMENTS_SHORT: usize = 32; diff --git a/vortex-array/benches/interleave.rs b/vortex-array/benches/interleave.rs index 8da63e9655b..4c79d28400a 100644 --- a/vortex-array/benches/interleave.rs +++ b/vortex-array/benches/interleave.rs @@ -14,6 +14,7 @@ use std::fmt::Display; use std::fmt::Formatter; +use std::sync::LazyLock; use divan::Bencher; use mimalloc::MiMalloc; @@ -25,17 +26,36 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::InterleaveArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; +use vortex_session::VortexSession; + +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -178,7 +198,6 @@ fn primitive_inputs( #[divan::bench(args = combos())] fn vortex(bencher: Bencher, combo: Combo) { let (values, array_indices, row_indices) = vortex_inputs(combo); - let session = array_session(); bencher .with_inputs(|| { ( @@ -189,7 +208,7 @@ fn vortex(bencher: Bencher, combo: Combo) { ) .unwrap() .into_array(), - session.create_execution_ctx(), + SESSION.create_execution_ctx(), ) }) .bench_refs(|(array, ctx)| array.clone().execute::(ctx)); @@ -197,7 +216,6 @@ fn vortex(bencher: Bencher, combo: Combo) { fn bench_primitive(bencher: Bencher, combo: Combo, mixed_constants: bool) { let (values, array_indices, row_indices) = primitive_inputs(combo, mixed_constants); - let session = array_session(); bencher .with_inputs(|| { ( @@ -208,7 +226,7 @@ fn bench_primitive(bencher: Bencher, combo: Combo, mixed_constants: bool) { ) .unwrap() .into_array(), - session.create_execution_ctx(), + SESSION.create_execution_ctx(), ) }) .bench_refs(|(array, ctx)| array.clone().execute::(ctx)); diff --git a/vortex-array/benches/kleene_bool.rs b/vortex-array/benches/kleene_bool.rs index 1f0bd2fb1d1..50916be1f9a 100644 --- a/vortex-array/benches/kleene_bool.rs +++ b/vortex-array/benches/kleene_bool.rs @@ -12,26 +12,37 @@ use vortex_array::ArrayRef; use vortex_array::Columnar; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } static SESSION: LazyLock = LazyLock::new(|| { VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() .with::() .with::() }); diff --git a/vortex-array/benches/like.rs b/vortex-array/benches/like.rs index 238341b66d1..1384c66986c 100644 --- a/vortex-array/benches/like.rs +++ b/vortex-array/benches/like.rs @@ -3,6 +3,8 @@ #![expect(clippy::unwrap_used)] +use std::sync::LazyLock; + use divan::Bencher; use mimalloc::MiMalloc; use rand::RngExt; @@ -12,16 +14,36 @@ use rand::prelude::StdRng; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::VarBinViewArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar_fn::fns::like::Like; use vortex_array::scalar_fn::fns::like::LikeOptions; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; +use vortex_session::VortexSession; + +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -46,7 +68,6 @@ fn strings() -> ArrayRef { } fn bench_like(bencher: Bencher, pattern: &str, options: LikeOptions) { - let session = vortex_array::array_session(); let array = strings(); bencher .with_inputs(|| { @@ -58,7 +79,7 @@ fn bench_like(bencher: Bencher, pattern: &str, options: LikeOptions) { ) .unwrap() .into_array(), - session.create_execution_ctx(), + SESSION.create_execution_ctx(), ) }) .bench_values(|(array, mut ctx)| array.execute::(&mut ctx).unwrap()); @@ -91,7 +112,6 @@ fn like_regex(bencher: Bencher) { #[divan::bench] fn like_per_row_patterns(bencher: Bencher) { - let session = vortex_array::array_session(); let array = strings(); // A non-constant pattern child takes the per-row path; repeated patterns hit the // compile cache. @@ -102,7 +122,7 @@ fn like_per_row_patterns(bencher: Bencher) { Like::try_new(array.clone(), patterns.clone(), LikeOptions::default()) .unwrap() .into_array(), - session.create_execution_ctx(), + SESSION.create_execution_ctx(), ) }) .bench_values(|(array, mut ctx)| array.execute::(&mut ctx).unwrap()); diff --git a/vortex-array/benches/list_contains_set.rs b/vortex-array/benches/list_contains_set.rs index b15931b2d9a..072678ec57d 100644 --- a/vortex-array/benches/list_contains_set.rs +++ b/vortex-array/benches/list_contains_set.rs @@ -10,6 +10,7 @@ #![expect(clippy::unwrap_used)] use std::sync::Arc; +use std::sync::LazyLock; use divan::Bencher; use mimalloc::MiMalloc; @@ -19,6 +20,7 @@ use rand::prelude::StdRng; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ListArray; @@ -27,15 +29,34 @@ use vortex_array::arrays::VarBinViewArray; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::list_contains; use vortex_array::expr::lit; use vortex_array::expr::root; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; +use vortex_session::VortexSession; + +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -63,7 +84,6 @@ fn random_i64(len: usize) -> (Vec, Vec) { } fn bench_in_set(bencher: Bencher, set: Scalar, needles: ArrayRef) { - let session = vortex_array::array_session(); // Optimized as a scan optimizes it, so the set arrives normalized. let expr = list_contains(lit(set), root()) .bind(needles.dtype()) @@ -74,7 +94,7 @@ fn bench_in_set(bencher: Bencher, set: Scalar, needles: ArrayRef) { .with_inputs(|| { ( needles.clone().apply_bound(&expr).unwrap(), - session.create_execution_ctx(), + SESSION.create_execution_ctx(), ) }) .bench_values(|(array, mut ctx)| array.execute::(&mut ctx).unwrap()); diff --git a/vortex-array/benches/list_length.rs b/vortex-array/benches/list_length.rs index 7084f26be55..a29a13a8cf4 100644 --- a/vortex-array/benches/list_length.rs +++ b/vortex-array/benches/list_length.rs @@ -21,12 +21,19 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ListArray; use vortex_array::arrays::ListViewArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::list_length; use vortex_array::expr::root; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -35,10 +42,20 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const BASE_LIST_SIZE: usize = 8; diff --git a/vortex-array/benches/list_sum.rs b/vortex-array/benches/list_sum.rs index a61ead4ceed..ef537e4617a 100644 --- a/vortex-array/benches/list_sum.rs +++ b/vortex-array/benches/list_sum.rs @@ -19,13 +19,20 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::ListArray; use vortex_array::arrays::ListViewArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::list_sum; use vortex_array::expr::root; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -34,10 +41,20 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const BASE_LIST_SIZE: usize = 8; diff --git a/vortex-array/benches/listview_builder_extend.rs b/vortex-array/benches/listview_builder_extend.rs index 1bdf17b7b39..d5c9047d711 100644 --- a/vortex-array/benches/listview_builder_extend.rs +++ b/vortex-array/benches/listview_builder_extend.rs @@ -6,12 +6,13 @@ #![expect(clippy::unwrap_used)] use std::sync::Arc; +use std::sync::LazyLock; use divan::Bencher; use mimalloc::MiMalloc; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ListViewArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::builders::ListViewBuilder; @@ -19,13 +20,32 @@ use vortex_array::dtype::DType; use vortex_array::dtype::Nullability::NonNullable; use vortex_array::dtype::Nullability::Nullable; use vortex_array::dtype::PType::I32; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; +use vortex_session::VortexSession; + +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -48,7 +68,7 @@ fn make_listview( step: usize, with_nulls: bool, ) -> ListViewArray { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let element_count = step * num_lists + list_size; let elements = PrimitiveArray::from_iter(0..element_count as i32).into_array(); let offsets: Buffer = (0..num_lists).map(|i| (i * step) as u32).collect(); @@ -78,7 +98,7 @@ fn extend_from_array_zctl(bencher: Bencher, (num_lists, list_size): (usize, usiz let source = source.into_array(); bencher.with_inputs(|| &source).bench_refs(|source| { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ListViewBuilder::::with_capacity_in( Arc::new(DType::Primitive(I32, NonNullable)), NonNullable, @@ -102,7 +122,7 @@ fn extend_from_array_non_zctl_overlapping( let source = source.into_array(); bencher.with_inputs(|| &source).bench_refs(|source| { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ListViewBuilder::::with_capacity_in( Arc::new(DType::Primitive(I32, NonNullable)), Nullable, diff --git a/vortex-array/benches/listview_rebuild.rs b/vortex-array/benches/listview_rebuild.rs index fc68d0595be..89b451692f6 100644 --- a/vortex-array/benches/listview_rebuild.rs +++ b/vortex-array/benches/listview_rebuild.rs @@ -13,7 +13,7 @@ use mimalloc::MiMalloc; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::ListArray; use vortex_array::arrays::ListViewArray; @@ -23,6 +23,12 @@ use vortex_array::arrays::VarBinViewArray; use vortex_array::arrays::listview::ListViewArraySlotsExt; use vortex_array::arrays::listview::ListViewRebuildMode; use vortex_array::dtype::FieldNames; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -36,7 +42,16 @@ fn main() { } /// A shared session for the `ListView` rebuild benchmarks, used to create execution contexts. -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn make_primitive_lv(num_lists: usize, list_size: usize, step: usize) -> ListViewArray { let mut ctx = SESSION.create_execution_ctx(); diff --git a/vortex-array/benches/listview_zip.rs b/vortex-array/benches/listview_zip.rs index 0756d0c0be5..b51356005aa 100644 --- a/vortex-array/benches/listview_zip.rs +++ b/vortex-array/benches/listview_zip.rs @@ -11,10 +11,16 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ListViewArray; use vortex_array::builtins::ArrayBuiltins; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BufferMut; use vortex_mask::Mask; @@ -24,10 +30,20 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); // Smaller than the value-path benches: listview zip cost is dominated by element concatenation and // per-list canonicalization. A few thousand lists already exercise the select while keeping each diff --git a/vortex-array/benches/patches_lookup.rs b/vortex-array/benches/patches_lookup.rs index c81fdaa573e..b8840d712cc 100644 --- a/vortex-array/benches/patches_lookup.rs +++ b/vortex-array/benches/patches_lookup.rs @@ -13,18 +13,34 @@ use rand::SeedableRng; use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::patches::PATCH_CHUNK_SIZE; use vortex_array::patches::Patches; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; use vortex_session::VortexSession; #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-array/benches/piecewise_sequence_take_primitive.rs b/vortex-array/benches/piecewise_sequence_take_primitive.rs index f2417ae973b..825f296fa6c 100644 --- a/vortex-array/benches/piecewise_sequence_take_primitive.rs +++ b/vortex-array/benches/piecewise_sequence_take_primitive.rs @@ -20,10 +20,16 @@ use rand::prelude::*; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::PiecewiseSequenceArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -34,7 +40,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const SOURCE_LEN: usize = 512 * 1024; // Sized to keep CodSpeed simulation under 1ms at run length 1. diff --git a/vortex-array/benches/primitive_zip.rs b/vortex-array/benches/primitive_zip.rs index ea36cba8114..070ed660ac5 100644 --- a/vortex-array/benches/primitive_zip.rs +++ b/vortex-array/benches/primitive_zip.rs @@ -15,9 +15,15 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::builtins::ArrayBuiltins; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BufferMut; use vortex_mask::Mask; @@ -31,7 +37,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); // Sized so the bench stays well under a few hundred microseconds under CodSpeed's instruction-count // simulation, which runs ~10x the local walltime; the branchless value blend is still exercised. diff --git a/vortex-array/benches/probe.rs b/vortex-array/benches/probe.rs index 57643787b2d..7a05001284e 100644 --- a/vortex-array/benches/probe.rs +++ b/vortex-array/benches/probe.rs @@ -12,11 +12,17 @@ use mimalloc::MiMalloc; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::DictArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::StructArray; use vortex_array::dtype::FieldNames; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_error::VortexExpect; @@ -35,7 +41,16 @@ const VALUES: usize = 1_024; // Sized to keep the CodSpeed simulation short per benchmark. const ACCESSES: usize = 256; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn nullable_primitive(len: usize) -> ArrayRef { PrimitiveArray::new( diff --git a/vortex-array/benches/row_fn_bool_retry.rs b/vortex-array/benches/row_fn_bool_retry.rs index a070a11a925..86c7a9b8c73 100644 --- a/vortex-array/benches/row_fn_bool_retry.rs +++ b/vortex-array/benches/row_fn_bool_retry.rs @@ -14,17 +14,23 @@ use divan::counter::ItemsCount; use mimalloc::MiMalloc; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::DType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar_fn::EmptyOptions; use vortex_array::scalar_fn::ScalarFnId; use vortex_array::scalar_fn::VecExecutionArgs; +use vortex_array::scalar_fn::session::ScalarFnSession; use vortex_array::scalar_fn::unstable::row::RowFn; use vortex_array::scalar_fn::unstable::row::RowVisitor; use vortex_array::scalar_fn::unstable::row::execute_rows; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_error::VortexExpect; use vortex_error::VortexResult; @@ -35,7 +41,16 @@ use vortex_session::registry::CachedId; #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const SIZES: &[usize] = &[16_384]; const BATCHES_PER_ITER: usize = 8; diff --git a/vortex-array/benches/row_fn_output.rs b/vortex-array/benches/row_fn_output.rs index 31c97ba77a2..c2a7dbf47e7 100644 --- a/vortex-array/benches/row_fn_output.rs +++ b/vortex-array/benches/row_fn_output.rs @@ -15,17 +15,23 @@ use mimalloc::MiMalloc; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::DType; use vortex_array::dtype::NativePType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar_fn::EmptyOptions; use vortex_array::scalar_fn::ScalarFnId; use vortex_array::scalar_fn::VecExecutionArgs; +use vortex_array::scalar_fn::session::ScalarFnSession; use vortex_array::scalar_fn::unstable::row::RowFn; use vortex_array::scalar_fn::unstable::row::RowVisitor; use vortex_array::scalar_fn::unstable::row::execute_rows; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; @@ -40,7 +46,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const ROWS: usize = 1 << 14; diff --git a/vortex-array/benches/row_fn_utf8_input.rs b/vortex-array/benches/row_fn_utf8_input.rs index 62dc4b3798f..f1c1a876353 100644 --- a/vortex-array/benches/row_fn_utf8_input.rs +++ b/vortex-array/benches/row_fn_utf8_input.rs @@ -14,18 +14,24 @@ use mimalloc::MiMalloc; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::VarBinArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar_fn::EmptyOptions; use vortex_array::scalar_fn::ScalarFnId; use vortex_array::scalar_fn::VecExecutionArgs; +use vortex_array::scalar_fn::session::ScalarFnSession; use vortex_array::scalar_fn::unstable::row::RowFn; use vortex_array::scalar_fn::unstable::row::RowVisitor; use vortex_array::scalar_fn::unstable::row::Utf8Column; use vortex_array::scalar_fn::unstable::row::execute_rows; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_session::VortexSession; @@ -39,7 +45,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const ROWS: usize = 1 << 14; diff --git a/vortex-array/benches/scalar_at_struct.rs b/vortex-array/benches/scalar_at_struct.rs index 4901028d0ed..662c571ea1a 100644 --- a/vortex-array/benches/scalar_at_struct.rs +++ b/vortex-array/benches/scalar_at_struct.rs @@ -14,9 +14,15 @@ use rand::rngs::StdRng; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::StructArray; use vortex_array::dtype::FieldNames; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -33,7 +39,16 @@ const ARRAY_SIZE: usize = 100_000; // Sized to keep the CodSpeed simulation under 1ms per benchmark. const NUM_ACCESSES: usize = 100; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[divan::bench] fn execute_scalar_struct_simple(bencher: Bencher) { diff --git a/vortex-array/benches/scalar_construction.rs b/vortex-array/benches/scalar_construction.rs index a1dcbfe596e..0f8e2a0b521 100644 --- a/vortex-array/benches/scalar_construction.rs +++ b/vortex-array/benches/scalar_construction.rs @@ -19,19 +19,25 @@ use vortex_array::aggregate_fn::AggregateFnVTableExt; use vortex_array::aggregate_fn::NumericalAggregateOpts; use vortex_array::aggregate_fn::fns::count::Count; use vortex_array::aggregate_fn::fns::sum_v2::SumV2; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::dtype::DType; use vortex_array::dtype::FieldNames; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; use vortex_array::dtype::StructFields; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::stats::Precision; use vortex_array::expr::stats::Stat; use vortex_array::expr::stats::StatsProvider; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::PValue; use vortex_array::scalar::Scalar; use vortex_array::scalar::ScalarValue; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; use vortex_array::stats::StatsSet; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; use vortex_buffer::BufferString; use vortex_session::VortexSession; @@ -43,7 +49,16 @@ const N: usize = 1024; /// A merge costs about 300ns, so it runs fewer times to keep the CodSpeed simulation under 1ms. const MERGES: usize = 64; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn main() { LazyLock::force(&SESSION); diff --git a/vortex-array/benches/scalar_fn_probe.rs b/vortex-array/benches/scalar_fn_probe.rs index 598d352bbe4..9a6e906b6d9 100644 --- a/vortex-array/benches/scalar_fn_probe.rs +++ b/vortex-array/benches/scalar_fn_probe.rs @@ -14,13 +14,19 @@ use rand::rngs::StdRng; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::ScalarFnArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar_fn::TypedScalarFnInstance; use vortex_array::scalar_fn::fns::binary::Binary; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -34,7 +40,16 @@ fn main() { const ARRAY_SIZE: usize = 100_000; const NUM_ACCESSES: usize = 50; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// evaluating ADD's validity is cheaper than evaluating ADD fn binary_add() -> ArrayRef { diff --git a/vortex-array/benches/scalar_subtract.rs b/vortex-array/benches/scalar_subtract.rs index de74f479bf0..64ab36158e5 100644 --- a/vortex-array/benches/scalar_subtract.rs +++ b/vortex-array/benches/scalar_subtract.rs @@ -14,12 +14,18 @@ use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ConstantArray; use vortex_array::builtins::ArrayBuiltins; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; use vortex_array::scalar_fn::fns::operators::Operator; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -31,7 +37,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[vortex_bench_support::cpu_features] #[divan::bench] diff --git a/vortex-array/benches/take_chunked.rs b/vortex-array/benches/take_chunked.rs index 0a5b1cffb22..768308e49b7 100644 --- a/vortex-array/benches/take_chunked.rs +++ b/vortex-array/benches/take_chunked.rs @@ -8,6 +8,7 @@ use std::fmt::Display; use std::fmt::Formatter; +use std::sync::LazyLock; use divan::Bencher; use divan::counter::ItemsCount; @@ -16,19 +17,38 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::StructArray; use vortex_array::dtype::FieldNames; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; +use vortex_session::VortexSession; + +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -341,11 +361,10 @@ fn take_indices(case: Case) -> ArrayRef { fn take(bencher: Bencher, case: Case) { let values = chunked_values(case); let indices = take_indices(case); - let session = array_session(); bencher .counter(ItemsCount::new(case.indices)) - .with_inputs(|| (indices.clone(), session.create_execution_ctx())) + .with_inputs(|| (indices.clone(), SESSION.create_execution_ctx())) .bench_refs(|(indices, ctx)| { values .take(indices.clone()) diff --git a/vortex-array/benches/take_filter.rs b/vortex-array/benches/take_filter.rs index ccec1c64e3a..ebd0d244639 100644 --- a/vortex-array/benches/take_filter.rs +++ b/vortex-array/benches/take_filter.rs @@ -29,9 +29,15 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ListArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_buffer::BitBufferMut; @@ -63,7 +69,16 @@ const INDEX_SEED: u64 = 43; const LIST_SIZE: usize = 4; const NULL_INDEX_INTERVAL: usize = 8; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn primitive_array() -> ArrayRef { PrimitiveArray::from_iter(0..ARRAY_LEN as u32).into_array() diff --git a/vortex-array/benches/take_fsl.rs b/vortex-array/benches/take_fsl.rs index bd1ecd862ca..0946e554e34 100644 --- a/vortex-array/benches/take_fsl.rs +++ b/vortex-array/benches/take_fsl.rs @@ -23,9 +23,15 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::FixedSizeListArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -38,7 +44,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Number of lists in the source array. const NUM_LISTS: usize = 500; diff --git a/vortex-array/benches/take_patches.rs b/vortex-array/benches/take_patches.rs index 1f91e873264..1be8a4b713d 100644 --- a/vortex-array/benches/take_patches.rs +++ b/vortex-array/benches/take_patches.rs @@ -14,9 +14,15 @@ use rand::rngs::StdRng; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::patches::Patches; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; use vortex_error::VortexExpect; use vortex_session::VortexSession; @@ -29,7 +35,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Sized to keep CodSpeed simulation under 1ms per benchmark. const ARRAY_LEN: usize = 4096; diff --git a/vortex-array/benches/take_primitive.rs b/vortex-array/benches/take_primitive.rs index 38ac41d7b97..6c962e762b2 100644 --- a/vortex-array/benches/take_primitive.rs +++ b/vortex-array/benches/take_primitive.rs @@ -17,9 +17,15 @@ use rand_distr::Zipf; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::DictArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -40,7 +46,16 @@ const GT_NUM_INDICES: &[usize] = &[1_000_000]; /// Size of the source vector / dictionary values. const VECTOR_SIZE: &[usize] = &[16, 256, 2048, 8192]; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[divan::bench(sample_count = 200)] fn primitive_take_u32(bencher: Bencher) { diff --git a/vortex-array/benches/take_struct.rs b/vortex-array/benches/take_struct.rs index 7ea4d0cc0c5..5d47f6a957f 100644 --- a/vortex-array/benches/take_struct.rs +++ b/vortex-array/benches/take_struct.rs @@ -14,9 +14,15 @@ use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::StructArray; use vortex_array::dtype::FieldNames; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -29,7 +35,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const ARRAY_SIZE: usize = 100_000; const TAKE_SIZE: usize = 1000; diff --git a/vortex-array/benches/take_varbin.rs b/vortex-array/benches/take_varbin.rs index 53ceb61f7da..422e32f5d25 100644 --- a/vortex-array/benches/take_varbin.rs +++ b/vortex-array/benches/take_varbin.rs @@ -13,10 +13,16 @@ use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::VarBinArray; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; use vortex_session::VortexSession; @@ -28,7 +34,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const ARRAY_SIZE: usize = 20_000; // Sized to keep CodSpeed simulation under 1ms. diff --git a/vortex-array/benches/validity_is_valid.rs b/vortex-array/benches/validity_is_valid.rs index 892c5c60278..76de81fc4ae 100644 --- a/vortex-array/benches/validity_is_valid.rs +++ b/vortex-array/benches/validity_is_valid.rs @@ -19,7 +19,13 @@ use std::sync::LazyLock; use divan::Bencher; use mimalloc::MiMalloc; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_session::VortexSession; @@ -28,6 +34,7 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -40,7 +47,16 @@ fn array_validity(len: usize) -> Validity { )) } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Per-element validity check over array-backed validity (the antipattern). This mirrors the /// deprecated `Validity::is_valid(i)`: a fresh `ExecutionCtx` plus a scalar lookup on every call. diff --git a/vortex-array/benches/varbinview_compact.rs b/vortex-array/benches/varbinview_compact.rs index a3beb74773c..332c74a1d7a 100644 --- a/vortex-array/benches/varbinview_compact.rs +++ b/vortex-array/benches/varbinview_compact.rs @@ -11,11 +11,17 @@ use rand::rngs::StdRng; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::VarBinViewArray; use vortex_array::builders::VarBinViewBuilder; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Buffer; use vortex_error::VortexExpect; use vortex_session::VortexSession; @@ -24,6 +30,7 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -37,7 +44,16 @@ const ARGS: &[(usize, usize)] = &[ (1 << 11, 10), ]; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); #[divan::bench(args = ARGS)] fn compact(bencher: Bencher, args: (usize, usize)) { diff --git a/vortex-array/benches/varbinview_fill_null.rs b/vortex-array/benches/varbinview_fill_null.rs index 59d6c7df0d8..8d46df382e8 100644 --- a/vortex-array/benches/varbinview_fill_null.rs +++ b/vortex-array/benches/varbinview_fill_null.rs @@ -11,12 +11,18 @@ use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::VarBinViewArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_session::VortexSession; #[global_allocator] @@ -27,7 +33,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); // Sized to keep CodSpeed simulation under 1ms per benchmark. const LEN: usize = 2_048; diff --git a/vortex-array/benches/varbinview_try_new.rs b/vortex-array/benches/varbinview_try_new.rs index a50f0b588f3..813c52806cd 100644 --- a/vortex-array/benches/varbinview_try_new.rs +++ b/vortex-array/benches/varbinview_try_new.rs @@ -7,11 +7,17 @@ use std::sync::LazyLock; use divan::Bencher; use mimalloc::MiMalloc; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::VarBinViewArray; use vortex_array::arrays::varbinview::BinaryView; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_buffer::Buffer; @@ -23,12 +29,22 @@ use vortex_session::VortexSession; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } const SIZES: &[usize] = &[1 << 12, 1 << 16]; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn garbage_view() -> BinaryView { BinaryView::new_ref(13, *b"AAAA", 0xDEAD_BEEF, 0xF000_0000) diff --git a/vortex-array/benches/varbinview_zip.rs b/vortex-array/benches/varbinview_zip.rs index 8d2a4db076d..1a7bc592e88 100644 --- a/vortex-array/benches/varbinview_zip.rs +++ b/vortex-array/benches/varbinview_zip.rs @@ -10,11 +10,17 @@ use mimalloc::MiMalloc; use vortex_array::IntoArray; use vortex_array::RecursiveCanonical; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::VarBinViewArray; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_mask::Mask; use vortex_session::VortexSession; @@ -26,7 +32,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Benchmarks zip on VarBinView arrays with a highly fragmented mask (worst case for per-slice lookup paths). #[divan::bench] diff --git a/vortex-array/src/aggregate_fn/accumulator.rs b/vortex-array/src/aggregate_fn/accumulator.rs index 2812e43b92f..388d92ffd2f 100644 --- a/vortex-array/src/aggregate_fn/accumulator.rs +++ b/vortex-array/src/aggregate_fn/accumulator.rs @@ -456,7 +456,7 @@ mod tests { } fn fresh_session() -> VortexSession { - crate::array_session() + VortexSession::empty() } fn dict_of_seven() -> ArrayRef { diff --git a/vortex-array/src/aggregate_fn/accumulator_grouped.rs b/vortex-array/src/aggregate_fn/accumulator_grouped.rs index 7c5cc224363..6405d993f40 100644 --- a/vortex-array/src/aggregate_fn/accumulator_grouped.rs +++ b/vortex-array/src/aggregate_fn/accumulator_grouped.rs @@ -408,7 +408,10 @@ fn fixed_size_list_group_ranges(groups: &FixedSizeListArray) -> GroupRanges { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; @@ -417,7 +420,6 @@ mod tests { use crate::aggregate_fn::GroupedAccumulator; use crate::aggregate_fn::NumericalAggregateOpts; use crate::aggregate_fn::fns::count::Count; - use crate::array_session; use crate::arrays::Chunked; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -425,6 +427,8 @@ mod tests { use crate::dtype::Nullability::NonNullable; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn accumulator() -> VortexResult> { GroupedAccumulator::try_new( Count, @@ -462,7 +466,7 @@ mod tests { assert_arrays_eq!( &flushed, &state([1, 2, 3, 4]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert!(accumulator.flush()?.is_empty()); Ok(()) diff --git a/vortex-array/src/aggregate_fn/fns/all_nan/mod.rs b/vortex-array/src/aggregate_fn/fns/all_nan/mod.rs index 2d3695c1fdf..884e161d23f 100644 --- a/vortex-array/src/aggregate_fn/fns/all_nan/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/all_nan/mod.rs @@ -154,7 +154,10 @@ impl AggregateFnVTable for AllNan { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -162,15 +165,16 @@ mod tests { use crate::aggregate_fn::DynAccumulator; use crate::aggregate_fn::EmptyOptions; use crate::aggregate_fn::fns::all_nan::AllNan; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn all_nan_aggregate_fn() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNan, EmptyOptions, dtype)?; @@ -183,7 +187,7 @@ mod tests { #[test] fn all_nan_false_with_non_nan() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNan, EmptyOptions, dtype)?; @@ -203,7 +207,7 @@ mod tests { #[test] fn all_nan_false_with_null() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNan, EmptyOptions, dtype)?; diff --git a/vortex-array/src/aggregate_fn/fns/all_non_distinct/tests.rs b/vortex-array/src/aggregate_fn/fns/all_non_distinct/tests.rs index 1afde24a260..3f894459e1d 100644 --- a/vortex-array/src/aggregate_fn/fns/all_non_distinct/tests.rs +++ b/vortex-array/src/aggregate_fn/fns/all_non_distinct/tests.rs @@ -1,16 +1,18 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use super::all_non_distinct; use crate::ArrayRef; use crate::ExecutionCtx; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::DecimalArray; @@ -27,6 +29,8 @@ use crate::dtype::Nullability; use crate::dtype::PType; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Baseline oracle: compare two arrays element-wise using `execute_scalar`. /// Returns true iff every position has the same scalar (null == null is true). fn scalar_baseline(a: &ArrayRef, b: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult { @@ -43,7 +47,7 @@ fn scalar_baseline(a: &ArrayRef, b: &ArrayRef, ctx: &mut ExecutionCtx) -> Vortex /// Assert that `all_non_distinct` agrees with the scalar baseline. fn assert_matches_baseline(a: &ArrayRef, b: &ArrayRef) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = scalar_baseline(a, b, &mut ctx)?; let actual = all_non_distinct(a, b, &mut ctx)?; assert_eq!( @@ -88,7 +92,7 @@ fn bool_non_nullable( ) -> VortexResult<()> { let a = BoolArray::from_iter(a.iter().copied()).into_array(); let b = BoolArray::from_iter(b.iter().copied()).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected); assert_matches_baseline(&a, &b) } @@ -121,7 +125,7 @@ fn bool_nullable( ) -> VortexResult<()> { let a = BoolArray::from_iter(a.iter().copied()).into_array(); let b = BoolArray::from_iter(b.iter().copied()).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected); assert_matches_baseline(&a, &b) } @@ -140,7 +144,7 @@ fn primitive_i32( ) -> VortexResult<()> { let a = PrimitiveArray::from_iter(a).into_array(); let b = PrimitiveArray::from_iter(b).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected); assert_matches_baseline(&a, &b) } @@ -206,7 +210,7 @@ fn primitive_nullable( ) -> VortexResult<()> { let a = PrimitiveArray::from_option_iter(a.iter().copied()).into_array(); let b = PrimitiveArray::from_option_iter(b.iter().copied()).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected); assert_matches_baseline(&a, &b) } @@ -235,7 +239,7 @@ fn strings_non_nullable( ) -> VortexResult<()> { let a = VarBinViewArray::from_iter_str(a.iter().copied()).into_array(); let b = VarBinViewArray::from_iter_str(b.iter().copied()).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected); assert_matches_baseline(&a, &b) } @@ -258,7 +262,7 @@ fn strings_nullable( ) -> VortexResult<()> { let a = VarBinViewArray::from_iter_nullable_str(a.iter().copied()).into_array(); let b = VarBinViewArray::from_iter_nullable_str(b.iter().copied()).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected); assert_matches_baseline(&a, &b) } @@ -399,7 +403,7 @@ fn struct_nested_nullable_fields() -> VortexResult<()> { #[test] fn list_identical() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![1i32, 2, 3, 4].into_array(); let a = ListViewArray::try_new( elements.clone(), @@ -422,7 +426,7 @@ fn list_identical() -> VortexResult<()> { #[test] fn list_different_elements() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = ListViewArray::try_new( buffer![1i32, 2, 3, 4].into_array(), buffer![0u32, 2].into_array(), @@ -444,7 +448,7 @@ fn list_different_elements() -> VortexResult<()> { #[test] fn list_different_lengths() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = ListViewArray::try_new( buffer![1i32, 2, 3].into_array(), buffer![0u32, 2].into_array(), @@ -462,7 +466,7 @@ fn list_different_lengths() -> VortexResult<()> { )? .into_array(); assert_matches_baseline(&a, &b)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(all_non_distinct(&a, &b, &mut ctx)?); let different = ListViewArray::try_new( buffer![1i32, 2, 3].into_array(), @@ -479,7 +483,7 @@ fn list_different_lengths() -> VortexResult<()> { #[test] fn list_nullable_ignores_garbage() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let validity = Validity::from_iter([true, false]); let a = ListViewArray::try_new( buffer![1i32, 2, 3, 4].into_array(), @@ -502,7 +506,7 @@ fn list_nullable_ignores_garbage() -> VortexResult<()> { #[test] fn list_different_offset_dtypes() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![1i32, 2, 3, 4].into_array(); let a = ListViewArray::try_new( elements.clone(), diff --git a/vortex-array/src/aggregate_fn/fns/all_non_nan/mod.rs b/vortex-array/src/aggregate_fn/fns/all_non_nan/mod.rs index 0a590f70f35..244dcd221ce 100644 --- a/vortex-array/src/aggregate_fn/fns/all_non_nan/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/all_non_nan/mod.rs @@ -144,7 +144,10 @@ impl AggregateFnVTable for AllNonNan { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -152,15 +155,16 @@ mod tests { use crate::aggregate_fn::DynAccumulator; use crate::aggregate_fn::EmptyOptions; use crate::aggregate_fn::fns::all_non_nan::AllNonNan; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn all_non_nan_aggregate_fn() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNonNan, EmptyOptions, dtype)?; @@ -173,7 +177,7 @@ mod tests { #[test] fn all_non_nan_false_with_nan() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNonNan, EmptyOptions, dtype)?; diff --git a/vortex-array/src/aggregate_fn/fns/all_non_null/mod.rs b/vortex-array/src/aggregate_fn/fns/all_non_null/mod.rs index a01bc07b4fb..6f10f2ce442 100644 --- a/vortex-array/src/aggregate_fn/fns/all_non_null/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/all_non_null/mod.rs @@ -138,7 +138,10 @@ impl AggregateFnVTable for AllNonNull { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -146,15 +149,16 @@ mod tests { use crate::aggregate_fn::DynAccumulator; use crate::aggregate_fn::EmptyOptions; use crate::aggregate_fn::fns::all_non_null::AllNonNull; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn all_non_null_aggregate_fn() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNonNull, EmptyOptions, dtype)?; @@ -167,7 +171,7 @@ mod tests { #[test] fn all_non_null_false_with_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNonNull, EmptyOptions, dtype)?; @@ -180,7 +184,7 @@ mod tests { #[test] fn all_non_null_true_for_empty_input() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNonNull, EmptyOptions, dtype)?; diff --git a/vortex-array/src/aggregate_fn/fns/all_null/mod.rs b/vortex-array/src/aggregate_fn/fns/all_null/mod.rs index 4082b2a00ef..aae98e0f5bd 100644 --- a/vortex-array/src/aggregate_fn/fns/all_null/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/all_null/mod.rs @@ -141,7 +141,10 @@ impl AggregateFnVTable for AllNull { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -149,15 +152,16 @@ mod tests { use crate::aggregate_fn::DynAccumulator; use crate::aggregate_fn::EmptyOptions; use crate::aggregate_fn::fns::all_null::AllNull; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn all_null_aggregate_fn() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNull, EmptyOptions, dtype)?; @@ -170,7 +174,7 @@ mod tests { #[test] fn all_null_false_with_non_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNull, EmptyOptions, dtype)?; @@ -183,7 +187,7 @@ mod tests { #[test] fn all_null_true_for_empty_input() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::Nullable); let mut acc = Accumulator::try_new(AllNull, EmptyOptions, dtype)?; diff --git a/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs b/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs index 4fedcc48c74..d9ae58f6669 100644 --- a/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs @@ -344,6 +344,7 @@ fn truncate_max(value: Scalar, max_bytes: usize) -> VortexResult> #[cfg(test)] mod tests { use std::num::NonZeroUsize; + use std::sync::LazyLock; use vortex_buffer::buffer; use vortex_error::VortexExpect; @@ -364,24 +365,25 @@ mod tests { use crate::aggregate_fn::fns::bounded_max::BoundedMaxState; use crate::aggregate_fn::fns::max::Max; use crate::aggregate_fn::fns::min::Min; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::VarBinViewArray; use crate::dtype::Nullability; use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn max_bytes(value: usize) -> NonZeroUsize { NonZeroUsize::new(value).vortex_expect("non-zero max_bytes") } fn fresh_session() -> VortexSession { - array_session() + VortexSession::empty() } #[test] fn bounded_max_truncates_utf8_to_upper_bound() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["aardvark", "char🪩"]).into_array(); let mut acc = Accumulator::try_new( BoundedMax, @@ -399,7 +401,7 @@ mod tests { #[test] fn bounded_max_unknown_upper_bound_returns_null() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_bin([&[255u8, 255, 255][..]]).into_array(); let mut acc = Accumulator::try_new( BoundedMax, @@ -417,7 +419,7 @@ mod tests { #[test] fn bounded_max_empty_does_not_poison_later_values() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let empty = VarBinViewArray::from_iter_bin(Vec::<&[u8]>::new()).into_array(); let values = VarBinViewArray::from_iter_bin([&[1u8][..]]).into_array(); let mut acc = Accumulator::try_new( @@ -440,7 +442,7 @@ mod tests { #[test] fn bounded_max_unknown_poisons_later_values() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let unknown = VarBinViewArray::from_iter_bin([&[255u8, 255, 255][..]]).into_array(); let values = VarBinViewArray::from_iter_bin([&[1u8][..]]).into_array(); let mut acc = Accumulator::try_new( @@ -504,7 +506,7 @@ mod tests { #[test] fn bounded_max_keeps_fixed_width_values_exact() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new(buffer![10i32, 20, 5], Validity::NonNullable).into_array(); let mut acc = Accumulator::try_new( BoundedMax, @@ -579,7 +581,7 @@ mod tests { let metadata = BoundedMax .serialize(&options)? .expect("serializable options"); - let roundtrip = BoundedMax.deserialize(&metadata, &VortexSession::empty())?; + let roundtrip = BoundedMax.deserialize(&metadata, &SESSION)?; assert_eq!(roundtrip, options); Ok(()) diff --git a/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs b/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs index 8c4e91178b0..c6c8b1ce7ed 100644 --- a/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs @@ -258,6 +258,7 @@ fn truncate_min(value: Scalar, max_bytes: usize) -> VortexResult> #[cfg(test)] mod tests { use std::num::NonZeroUsize; + use std::sync::LazyLock; use vortex_buffer::buffer; use vortex_error::VortexExpect; @@ -276,24 +277,25 @@ mod tests { use crate::aggregate_fn::fns::bounded_min::BoundedMinOptions; use crate::aggregate_fn::fns::max::Max; use crate::aggregate_fn::fns::min::Min; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::VarBinViewArray; use crate::dtype::Nullability; use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn max_bytes(value: usize) -> NonZeroUsize { NonZeroUsize::new(value).vortex_expect("non-zero max_bytes") } fn fresh_session() -> VortexSession { - array_session() + VortexSession::empty() } #[test] fn bounded_min_truncates_utf8_to_lower_bound() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["snowman⛄️snowman", "untruncated"]).into_array(); let mut acc = Accumulator::try_new( @@ -315,7 +317,7 @@ mod tests { #[test] fn bounded_min_keeps_fixed_width_values_exact() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new(buffer![10i32, 20, 5], Validity::NonNullable).into_array(); let mut acc = Accumulator::try_new( BoundedMin, @@ -413,7 +415,7 @@ mod tests { let metadata = BoundedMin .serialize(&options)? .expect("serializable options"); - let roundtrip = BoundedMin.deserialize(&metadata, &VortexSession::empty())?; + let roundtrip = BoundedMin.deserialize(&metadata, &SESSION)?; assert_eq!(roundtrip, options); Ok(()) diff --git a/vortex-array/src/aggregate_fn/fns/count/grouped.rs b/vortex-array/src/aggregate_fn/fns/count/grouped.rs index 5831e2eb985..1add20326b9 100644 --- a/vortex-array/src/aggregate_fn/fns/count/grouped.rs +++ b/vortex-array/src/aggregate_fn/fns/count/grouped.rs @@ -86,8 +86,11 @@ fn valid_count(elem_mask: &Mask, offset: usize, size: usize) -> usize { mod tests { #![allow(clippy::cast_possible_truncation)] + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::ExecutionCtx; @@ -97,7 +100,6 @@ mod tests { use crate::aggregate_fn::GroupedAccumulator; use crate::aggregate_fn::NumericalAggregateOpts; use crate::aggregate_fn::fns::count::Count; - use crate::array_session; use crate::arrays::FixedSizeListArray; use crate::arrays::ListViewArray; use crate::arrays::PrimitiveArray; @@ -109,6 +111,8 @@ mod tests { use crate::dtype::PType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Run a grouped count through the accumulator. fn grouped_count_actual( groups: &ArrayRef, @@ -125,7 +129,7 @@ mod tests { } fn listview(elements: ArrayRef, ranges: &[(usize, usize)]) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let offsets = PrimitiveArray::from_iter(ranges.iter().map(|&(o, _)| o as i32)); let sizes = PrimitiveArray::from_iter(ranges.iter().map(|&(_, s)| s as i32)); Ok(ListViewArray::try_new( @@ -140,7 +144,7 @@ mod tests { #[test] fn listview_counts_all_valid() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::new(buffer![1i32, 2, 3, 4, 5, 6], Validity::NonNullable).into_array(); let elem_dtype = DType::Primitive(PType::I32, NonNullable); @@ -157,7 +161,7 @@ mod tests { #[test] fn listview_counts_with_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, None, Some(9)]) .into_array(); @@ -175,7 +179,7 @@ mod tests { #[test] fn listview_counts_varbinview_with_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = VarBinViewArray::from_iter_nullable_str([ Some("a"), None, @@ -197,7 +201,7 @@ mod tests { #[test] fn fixed_size_counts_float_nans() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_option_iter([Some(1.0f64), Some(f64::NAN), None, Some(2.0)]) .into_array(); @@ -221,7 +225,7 @@ mod tests { #[test] fn fixed_size_counts_with_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4)]).into_array(); let elem_dtype = DType::Primitive(PType::I32, Nullable); diff --git a/vortex-array/src/aggregate_fn/fns/count/mod.rs b/vortex-array/src/aggregate_fn/fns/count/mod.rs index 8f9c83f4cbb..ba9a97fc7f8 100644 --- a/vortex-array/src/aggregate_fn/fns/count/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/count/mod.rs @@ -172,7 +172,7 @@ mod tests { use crate::scalar::ScalarValue; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); pub fn count(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult { let mut acc = Accumulator::try_new( diff --git a/vortex-array/src/aggregate_fn/fns/first/mod.rs b/vortex-array/src/aggregate_fn/fns/first/mod.rs index b60674cd30a..5f614532482 100644 --- a/vortex-array/src/aggregate_fn/fns/first/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/first/mod.rs @@ -153,8 +153,11 @@ impl AggregateFnVTable for First { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -165,7 +168,6 @@ mod tests { use crate::aggregate_fn::EmptyOptions; use crate::aggregate_fn::fns::first::First; use crate::aggregate_fn::fns::first::first; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; @@ -177,10 +179,12 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn first_non_null() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![10i32, 20, 30], Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(first(&array, &mut ctx)?, Scalar::primitive(10i32, Nullable)); Ok(()) } @@ -189,7 +193,7 @@ mod tests { fn first_skips_leading_nulls() -> VortexResult<()> { let array = PrimitiveArray::from_option_iter([None, None, Some(7i32), Some(8)]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(first(&array, &mut ctx)?, Scalar::primitive(7i32, Nullable)); Ok(()) } @@ -197,7 +201,7 @@ mod tests { #[test] fn first_all_null() -> VortexResult<()> { let array = PrimitiveArray::from_option_iter::([None, None, None]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullable); assert_eq!(first(&array, &mut ctx)?, Scalar::null(dtype)); Ok(()) @@ -215,7 +219,7 @@ mod tests { #[test] fn first_constant() -> VortexResult<()> { let array = ConstantArray::new(42i32, 10).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(first(&array, &mut ctx)?, Scalar::primitive(42i32, Nullable)); Ok(()) } @@ -224,7 +228,7 @@ mod tests { fn first_constant_null() -> VortexResult<()> { let dtype = DType::Primitive(PType::I32, Nullable); let array = ConstantArray::new(Scalar::null(dtype.clone()), 10).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(first(&array, &mut ctx)?, Scalar::null(dtype)); Ok(()) } @@ -236,14 +240,14 @@ mod tests { DType::Utf8(Nullable), ) .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(first(&array, &mut ctx)?, Scalar::utf8("hello", Nullable)); Ok(()) } #[test] fn first_multi_batch_picks_earliest_non_null() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullable); let mut acc = Accumulator::try_new(First, EmptyOptions, dtype)?; @@ -268,7 +272,7 @@ mod tests { #[test] fn first_finish_resets_state() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let mut acc = Accumulator::try_new(First, EmptyOptions, dtype)?; @@ -312,7 +316,7 @@ mod tests { let chunk2 = PrimitiveArray::from_option_iter([None, Some(42i32), Some(100)]); let dtype = chunk1.dtype().clone(); let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( first(&chunked.into_array(), &mut ctx)?, Scalar::primitive(42i32, Nullable) diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs b/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs index 7bc53ea4811..ff8e526402b 100644 --- a/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs @@ -467,10 +467,13 @@ impl AggregateFnVTable for IsConstant { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray as _; use crate::VortexSessionExecute; @@ -482,7 +485,6 @@ mod tests { use crate::aggregate_fn::fns::is_constant::IsConstant; use crate::aggregate_fn::fns::is_constant::IsConstantPartial; use crate::aggregate_fn::fns::is_constant::is_constant; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -501,6 +503,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + type MapEntryFixture<'a> = (i32, Option<&'a str>); type MapRowFixture<'a> = Option>>; @@ -545,7 +549,7 @@ mod tests { // Tests migrated from compute/is_constant.rs #[test] fn is_constant_min_max_no_nan() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = buffer![0, 1].into_array(); arr.statistics() @@ -564,7 +568,7 @@ mod tests { #[test] fn is_constant_min_max_with_nan() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::from_iter([0.0, 0.0, f32::NAN]).into_array(); arr.statistics() @@ -591,7 +595,7 @@ mod tests { }, false)] fn test_bool_is_constant(#[case] input: Vec, #[case] expected: bool) -> VortexResult<()> { let array = BoolArray::from_iter(input); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(is_constant(&array.into_array(), &mut ctx)?, expected); Ok(()) } @@ -611,7 +615,7 @@ mod tests { )? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(is_constant(&chunked, &mut ctx)?); Ok(()) } @@ -619,7 +623,7 @@ mod tests { // Tests migrated from arrays/decimal/compute/is_constant.rs #[test] fn test_decimal_is_constant() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = DecimalArray::new( buffer![0i128, 1i128, 2i128], @@ -640,7 +644,7 @@ mod tests { // Tests migrated from arrays/list/compute/is_constant.rs #[test] fn test_is_constant_nested_list() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let xs = ListArray::try_new( buffer![0i32, 1, 0, 1].into_array(), @@ -697,17 +701,17 @@ mod tests { PrimitiveArray::from_iter(elements).into_array(), PrimitiveArray::from_iter(offsets).into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(is_constant(&list_array.into_array(), &mut ctx)?, expected); Ok(()) } #[test] fn test_list_is_constant_nested_lists() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let inner_elements = buffer![1i32, 2, 1, 2].into_array(); let inner_offsets = buffer![0u32, 1, 2, 3, 4].into_array(); let inner_lists = ListArray::try_new( @@ -725,7 +729,7 @@ mod tests { &mut ctx, )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Both outer lists contain [[1], [2]], so should be constant assert!(is_constant(&outer_list.into_array(), &mut ctx)?); Ok(()) @@ -768,17 +772,17 @@ mod tests { PrimitiveArray::from_iter(elements).into_array(), PrimitiveArray::from_iter(offsets).into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(is_constant(&list_array.into_array(), &mut ctx)?, expected); Ok(()) } #[test] fn test_map_is_constant() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let identical = map_array_from_rows(&[ Some(vec![(1, Some("one")), (2, None)]), @@ -800,7 +804,7 @@ mod tests { #[test] fn empty_constant_leaves_partial_empty() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = ConstantArray::new(Scalar::from(99i32), 0).into_array(); let mut acc = Accumulator::try_new(IsConstant, EmptyOptions, array.dtype().clone())?; @@ -814,7 +818,7 @@ mod tests { /// in the partial scalar rather than collapsing it to the empty state. #[test] fn non_constant_merged_into_empty_keeps_verdict() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let mut empty = Accumulator::try_new(IsConstant, EmptyOptions, dtype.clone())?; let mut varying = Accumulator::try_new(IsConstant, EmptyOptions, dtype)?; diff --git a/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs b/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs index 89775ce2dfa..402eb1f6fb8 100644 --- a/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs @@ -594,11 +594,14 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -611,7 +614,6 @@ mod tests { use crate::aggregate_fn::fns::is_sorted::IsSortedPartial; use crate::aggregate_fn::fns::is_sorted::is_sorted; use crate::aggregate_fn::fns::is_sorted::is_strict_sorted; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; @@ -621,10 +623,12 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + // Tests migrated from compute/is_sorted.rs #[test] fn test_is_sorted() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::new(buffer!(0, 1, 2, 3), Validity::AllValid).into_array(); assert!(is_sorted(&arr, &mut ctx)?); @@ -658,7 +662,7 @@ mod tests { #[test] fn test_is_strict_sorted() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::new(buffer!(0, 1, 2, 3), Validity::AllValid).into_array(); assert!(is_strict_sorted(&arr, &mut ctx)?); @@ -695,7 +699,7 @@ mod tests { #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(1)]), true)] #[case(PrimitiveArray::from_option_iter([None, Some(5_u8), None]), false)] fn test_primitive_is_sorted(#[case] array: PrimitiveArray, #[case] expected: bool) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( is_sorted(&array.into_array(), &mut ctx) .vortex_expect("operation should succeed in test"), @@ -710,7 +714,7 @@ mod tests { #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(1), None]), false)] #[case(PrimitiveArray::from_option_iter([None, Some(5_u8), None]), false)] fn test_primitive_is_strict_sorted(#[case] array: PrimitiveArray, #[case] expected: bool) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( is_strict_sorted(&array.into_array(), &mut ctx) .vortex_expect("operation should succeed in test"), @@ -724,7 +728,7 @@ mod tests { use crate::arrays::DecimalArray; use crate::dtype::DecimalDType; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(19, 2); // "100.00" and "200.00" at scale 2. let i100 = 10_000i128; @@ -747,7 +751,7 @@ mod tests { use crate::arrays::DecimalArray; use crate::dtype::DecimalDType; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // "100.00", "200.00" and "300.00" at scale 2. let i100 = 10_000i128; let i200 = 20_000i128; @@ -772,7 +776,7 @@ mod tests { #[test] fn empty_constant_leaves_partial_empty() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = ConstantArray::new(Scalar::from(99i32), 0).into_array(); let options = IsSortedOptions { strict: false }; let mut acc = Accumulator::try_new(IsSorted, options, array.dtype().clone())?; @@ -787,7 +791,7 @@ mod tests { /// both the finalized result and the partial scalar. #[test] fn unsorted_merged_into_empty_keeps_verdict() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let options = IsSortedOptions { strict: false }; let mut empty = Accumulator::try_new(IsSorted, options.clone(), dtype.clone())?; diff --git a/vortex-array/src/aggregate_fn/fns/last/mod.rs b/vortex-array/src/aggregate_fn/fns/last/mod.rs index 55c44224600..1a631ede3a0 100644 --- a/vortex-array/src/aggregate_fn/fns/last/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/last/mod.rs @@ -151,8 +151,11 @@ impl AggregateFnVTable for Last { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -163,7 +166,6 @@ mod tests { use crate::aggregate_fn::EmptyOptions; use crate::aggregate_fn::fns::last::Last; use crate::aggregate_fn::fns::last::last; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; @@ -175,10 +177,12 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn last_non_null() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![10i32, 20, 30], Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(last(&array, &mut ctx)?, Scalar::primitive(30i32, Nullable)); Ok(()) } @@ -187,7 +191,7 @@ mod tests { fn last_skips_trailing_nulls() -> VortexResult<()> { let array = PrimitiveArray::from_option_iter([Some(7i32), Some(8), None, None]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(last(&array, &mut ctx)?, Scalar::primitive(8i32, Nullable)); Ok(()) } @@ -195,7 +199,7 @@ mod tests { #[test] fn last_all_null() -> VortexResult<()> { let array = PrimitiveArray::from_option_iter::([None, None, None]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullable); assert_eq!(last(&array, &mut ctx)?, Scalar::null(dtype)); Ok(()) @@ -213,7 +217,7 @@ mod tests { #[test] fn last_constant() -> VortexResult<()> { let array = ConstantArray::new(42i32, 10).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(last(&array, &mut ctx)?, Scalar::primitive(42i32, Nullable)); Ok(()) } @@ -222,7 +226,7 @@ mod tests { fn last_constant_null() -> VortexResult<()> { let dtype = DType::Primitive(PType::I32, Nullable); let array = ConstantArray::new(Scalar::null(dtype.clone()), 10).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(last(&array, &mut ctx)?, Scalar::null(dtype)); Ok(()) } @@ -234,14 +238,14 @@ mod tests { DType::Utf8(Nullable), ) .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(last(&array, &mut ctx)?, Scalar::utf8("world", Nullable)); Ok(()) } #[test] fn last_multi_batch_picks_latest_non_null() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullable); let mut acc = Accumulator::try_new(Last, EmptyOptions, dtype)?; @@ -266,7 +270,7 @@ mod tests { #[test] fn last_finish_resets_state() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let mut acc = Accumulator::try_new(Last, EmptyOptions, dtype)?; @@ -312,7 +316,7 @@ mod tests { let chunk2 = PrimitiveArray::from_option_iter::([None, None]); let dtype = chunk1.dtype().clone(); let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( last(&chunked.into_array(), &mut ctx)?, Scalar::primitive(100i32, Nullable) diff --git a/vortex-array/src/aggregate_fn/fns/max/mod.rs b/vortex-array/src/aggregate_fn/fns/max/mod.rs index bd4212ace62..ad6fee779eb 100644 --- a/vortex-array/src/aggregate_fn/fns/max/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/max/mod.rs @@ -234,8 +234,11 @@ impl AggregateFnVTable for Max { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray as _; use crate::VortexSessionExecute; @@ -243,7 +246,6 @@ mod tests { use crate::aggregate_fn::DynAccumulator; use crate::aggregate_fn::NumericalAggregateOpts; use crate::aggregate_fn::fns::max::Max; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::Nullability; @@ -254,9 +256,11 @@ mod tests { use crate::scalar::ScalarValue; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn max_aggregate_fn() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let mut acc = Accumulator::try_new(Max, NumericalAggregateOpts::default(), dtype)?; @@ -287,7 +291,7 @@ mod tests { #[test] fn max_with_nan_not_skipping() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F64, Nullability::NonNullable); let mut acc = Accumulator::try_new(Max, NumericalAggregateOpts::include_nans(), dtype)?; @@ -308,7 +312,7 @@ mod tests { #[test] fn max_not_skipping_with_exact_nan_count_stat() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // The exact NaN count agrees with the batch; including NaNs must poison the result. let batch = PrimitiveArray::new(buffer![1.0f64, 2.0, f64::NAN], Validity::NonNullable).into_array(); @@ -335,7 +339,7 @@ mod tests { fn max_nan_including_nullable_cached_stat() -> VortexResult<()> { // A nullable float array's cached Max stat is reconstructed as a nullable scalar. The // NaN-including shortcircuit merges it as-is; `to_scalar` re-casts to the result dtype. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::from_option_iter([Some(1.0f64), Some(2.0), Some(3.0)]).into_array(); array @@ -359,7 +363,7 @@ mod tests { #[test] fn max_casts_nonnullable_legacy_stat_to_nullable_partial() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let batch = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array(); batch .statistics() diff --git a/vortex-array/src/aggregate_fn/fns/mean/mod.rs b/vortex-array/src/aggregate_fn/fns/mean/mod.rs index e95e3e25ca8..b2dcf09fab4 100644 --- a/vortex-array/src/aggregate_fn/fns/mean/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/mean/mod.rs @@ -217,14 +217,16 @@ fn finalize_decimal_scalar( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::*; use crate::VortexSessionExecute; use crate::aggregate_fn::DynGroupedAccumulator; use crate::aggregate_fn::GroupedAccumulator; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::DecimalArray; @@ -234,11 +236,13 @@ mod tests { use crate::dtype::DecimalDType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn mean_all_valid() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![1.0f64, 2.0, 3.0, 4.0, 5.0], Validity::NonNullable) .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array, &mut ctx)?; assert_eq!(result.as_primitive().as_::(), Some(3.0)); Ok(()) @@ -247,7 +251,7 @@ mod tests { #[test] fn mean_with_nulls() -> VortexResult<()> { let array = PrimitiveArray::from_option_iter([Some(2.0f64), None, Some(4.0)]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array, &mut ctx)?; assert_eq!(result.as_primitive().as_::(), Some(3.0)); Ok(()) @@ -256,7 +260,7 @@ mod tests { #[test] fn mean_integers() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![10i32, 20, 30], Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array, &mut ctx)?; assert_eq!(result.as_primitive().as_::(), Some(20.0)); Ok(()) @@ -265,7 +269,7 @@ mod tests { #[test] fn mean_bool() -> VortexResult<()> { let array: BoolArray = [true, false, true, true].into_iter().collect(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array.into_array(), &mut ctx)?; assert_eq!(result.as_primitive().as_::(), Some(0.75)); Ok(()) @@ -274,7 +278,7 @@ mod tests { #[test] fn mean_constant_non_null() -> VortexResult<()> { let array = ConstantArray::new(5.0f64, 4); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array.into_array(), &mut ctx)?; assert_eq!(result.as_primitive().as_::(), Some(5.0)); Ok(()) @@ -286,7 +290,7 @@ mod tests { let chunk2 = PrimitiveArray::from_option_iter([Some(5.0f64), None]); let dtype = chunk1.dtype().clone(); let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&chunked.into_array(), &mut ctx)?; assert_eq!(result.as_primitive().as_::(), Some(3.0)); Ok(()) @@ -297,7 +301,7 @@ mod tests { // NaNs are excluded from both the sum and the count. let array = PrimitiveArray::new(buffer![1.0f64, f64::NAN, 3.0], Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array, &mut ctx)?; assert_eq!(result.as_primitive().as_::(), Some(2.0)); Ok(()) @@ -307,7 +311,7 @@ mod tests { fn mean_with_nan_not_skipping() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![1.0f64, f64::NAN, 3.0], Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let keep_nans = NumericalAggregateOpts::include_nans(); let mut acc = Accumulator::try_new( Mean::combined(), @@ -323,7 +327,7 @@ mod tests { #[test] fn mean_all_null_returns_null() -> VortexResult<()> { let array = PrimitiveArray::from_option_iter::([None, None, None]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array, &mut ctx)?; assert_eq!(result.as_primitive().as_::(), None); Ok(()) @@ -334,7 +338,7 @@ mod tests { let dtype = DecimalDType::new(6, 2); let array = DecimalArray::new(buffer![100i32, 200, 300], dtype, Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array, &mut ctx)?; assert_eq!( result.dtype(), @@ -353,7 +357,7 @@ mod tests { let dtype = DecimalDType::new(6, 2); let validity = Validity::from_iter([true, false, true]); let array = DecimalArray::new(buffer![150i32, 0, 450], dtype, validity).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array, &mut ctx)?; // mean(1.50, 4.50) = 3.000000 assert_eq!( @@ -375,7 +379,7 @@ mod tests { let chunk2 = DecimalArray::new(buffer![300i32, 400, 500], dtype, validity).into_array(); let dtype = chunk1.dtype().clone(); let chunked = ChunkedArray::try_new(vec![chunk1, chunk2], dtype)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&chunked.into_array(), &mut ctx)?; // mean(1.00, 2.00, 3.00, 4.00, 5.00) = 3.000000 assert_eq!( @@ -394,7 +398,7 @@ mod tests { let dtype = DecimalDType::new(6, 2); let buf = buffer![100i32, 0, 0]; let array = DecimalArray::new(buf, dtype, Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mean(&array, &mut ctx)?; // mean(1.00, 0.00, 0.00) = 1/3 => 0.333333 assert_eq!( @@ -410,7 +414,7 @@ mod tests { #[test] fn mean_multi_batch() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F64, Nullability::NonNullable); let mut acc = Accumulator::try_new( Mean::combined(), @@ -445,7 +449,7 @@ mod tests { #[test] fn mean_combined_partials() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for (case, (group, expected)) in mean_nan_null().into_iter().enumerate() { let mut acc = Accumulator::try_new( Mean::combined(), @@ -483,7 +487,7 @@ mod tests { ), DType::Primitive(PType::F64, Nullability::Nullable), )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); acc.accumulate_list(&groups.into_array(), &mut ctx)?; let result = acc.finish()?; diff --git a/vortex-array/src/aggregate_fn/fns/min/mod.rs b/vortex-array/src/aggregate_fn/fns/min/mod.rs index d5ae771d58e..77fe6861ba6 100644 --- a/vortex-array/src/aggregate_fn/fns/min/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/min/mod.rs @@ -234,8 +234,11 @@ impl AggregateFnVTable for Min { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray as _; use crate::VortexSessionExecute; @@ -243,7 +246,6 @@ mod tests { use crate::aggregate_fn::DynAccumulator; use crate::aggregate_fn::NumericalAggregateOpts; use crate::aggregate_fn::fns::min::Min; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::Nullability; @@ -254,9 +256,11 @@ mod tests { use crate::scalar::ScalarValue; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn min_aggregate_fn() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let mut acc = Accumulator::try_new(Min, NumericalAggregateOpts::default(), dtype)?; @@ -287,7 +291,7 @@ mod tests { #[test] fn min_with_nan_not_skipping() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F64, Nullability::NonNullable); let mut acc = Accumulator::try_new(Min, NumericalAggregateOpts::include_nans(), dtype)?; @@ -308,7 +312,7 @@ mod tests { #[test] fn min_not_skipping_with_exact_nan_count_stat() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // The exact NaN count agrees with the batch; including NaNs must poison the result. let batch = PrimitiveArray::new(buffer![1.0f64, 2.0, f64::NAN], Validity::NonNullable).into_array(); @@ -335,7 +339,7 @@ mod tests { fn min_nan_including_nullable_cached_stat() -> VortexResult<()> { // A nullable float array's cached Min stat is reconstructed as a nullable scalar. The // NaN-including shortcircuit merges it as-is; `to_scalar` re-casts to the result dtype. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::from_option_iter([Some(1.0f64), Some(2.0), Some(3.0)]).into_array(); array @@ -359,7 +363,7 @@ mod tests { #[test] fn min_casts_nonnullable_legacy_stat_to_nullable_partial() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let batch = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array(); batch .statistics() diff --git a/vortex-array/src/aggregate_fn/fns/min_max/mod.rs b/vortex-array/src/aggregate_fn/fns/min_max/mod.rs index cfc4d471259..8aa0e559e84 100644 --- a/vortex-array/src/aggregate_fn/fns/min_max/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/min_max/mod.rs @@ -555,7 +555,7 @@ mod tests { use crate::scalar::ScalarValue; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_prim_min_max() -> VortexResult<()> { diff --git a/vortex-array/src/aggregate_fn/fns/min_max/varbinview.rs b/vortex-array/src/aggregate_fn/fns/min_max/varbinview.rs index 066e9e473c7..ecc1e30afbb 100644 --- a/vortex-array/src/aggregate_fn/fns/min_max/varbinview.rs +++ b/vortex-array/src/aggregate_fn/fns/min_max/varbinview.rs @@ -178,7 +178,7 @@ mod tests { use crate::arrays::VarBinViewArray; use crate::dtype::Nullability; - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); fn utf8_min_max(values: &[Option<&str>]) -> VortexResult> { let array = diff --git a/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs b/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs index 455a0e51fd3..d77d6dc5a26 100644 --- a/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs @@ -222,8 +222,11 @@ impl AggregateFnVTable for NanCount { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -234,7 +237,6 @@ mod tests { use crate::aggregate_fn::EmptyOptions; use crate::aggregate_fn::fns::nan_count::NanCount; use crate::aggregate_fn::fns::nan_count::nan_count; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; @@ -243,9 +245,11 @@ mod tests { use crate::dtype::PType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn nan_count_multi_batch() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F64, Nullability::NonNullable); let mut acc = Accumulator::try_new(NanCount, EmptyOptions, dtype)?; @@ -265,7 +269,7 @@ mod tests { #[test] fn nan_count_finish_resets_state() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F64, Nullability::NonNullable); let mut acc = Accumulator::try_new(NanCount, EmptyOptions, dtype)?; @@ -298,7 +302,7 @@ mod tests { #[test] fn nan_count_constant_nan() -> VortexResult<()> { let array = ConstantArray::new(f64::NAN, 10); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(nan_count(&array.into_array(), &mut ctx)?, 10); Ok(()) } @@ -306,7 +310,7 @@ mod tests { #[test] fn nan_count_constant_non_nan() -> VortexResult<()> { let array = ConstantArray::new(1.0f64, 10); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(nan_count(&array.into_array(), &mut ctx)?, 0); Ok(()) } @@ -326,7 +330,7 @@ mod tests { let chunk2 = PrimitiveArray::from_option_iter([Some(f64::NAN), Some(f64::NAN), None]); let dtype = chunk1.dtype().clone(); let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(nan_count(&chunked.into_array(), &mut ctx)?, 3); Ok(()) } @@ -334,7 +338,7 @@ mod tests { #[test] fn nan_count_all_null() -> VortexResult<()> { let p = PrimitiveArray::new(buffer![f64::NAN, f64::NAN, f64::NAN], Validity::AllInvalid); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 0); Ok(()) } diff --git a/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs b/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs index c3b7e2818e1..bf380bc4a3f 100644 --- a/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs +++ b/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs @@ -38,16 +38,20 @@ fn compute_nan_count_with_validity(values: &[T], validity: Mask) #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; use crate::aggregate_fn::fns::nan_count::nan_count; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn primitive_nan_count() -> VortexResult<()> { let p = PrimitiveArray::new( @@ -62,7 +66,7 @@ mod tests { ], Validity::NonNullable, ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 2); Ok(()) } @@ -73,7 +77,7 @@ mod tests { buffer![f64::NAN, f64::NAN, f64::NAN, 1.0], Validity::from_iter([true, false, true, true]), ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 2); Ok(()) } @@ -81,7 +85,7 @@ mod tests { #[test] fn primitive_nan_count_all_valid_no_nans() -> VortexResult<()> { let p = PrimitiveArray::new(buffer![1.0f64, 2.0, 3.0], Validity::NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 0); Ok(()) } diff --git a/vortex-array/src/aggregate_fn/fns/null_count/mod.rs b/vortex-array/src/aggregate_fn/fns/null_count/mod.rs index e856943052d..adf35c24c89 100644 --- a/vortex-array/src/aggregate_fn/fns/null_count/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/null_count/mod.rs @@ -173,7 +173,10 @@ impl AggregateFnVTable for NullCount { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -182,7 +185,6 @@ mod tests { use crate::aggregate_fn::EmptyOptions; use crate::aggregate_fn::fns::null_count::NullCount; use crate::aggregate_fn::fns::null_count::null_count; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::Nullability; @@ -191,11 +193,13 @@ mod tests { use crate::expr::stats::Stat; use crate::expr::stats::StatsProviderExt; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn null_count_with_nulls() -> VortexResult<()> { let array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(null_count(&array, &mut ctx)?, 2); assert_eq!( @@ -207,7 +211,7 @@ mod tests { #[test] fn null_count_multi_batch() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::Nullable); let mut acc = Accumulator::try_new(NullCount, EmptyOptions, dtype)?; diff --git a/vortex-array/src/aggregate_fn/fns/sum/bool.rs b/vortex-array/src/aggregate_fn/fns/sum/bool.rs index f15356caaa1..d6c42f31ba3 100644 --- a/vortex-array/src/aggregate_fn/fns/sum/bool.rs +++ b/vortex-array/src/aggregate_fn/fns/sum/bool.rs @@ -34,7 +34,10 @@ pub(crate) fn accumulate_bool( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::aggregate_fn::Accumulator; @@ -43,20 +46,18 @@ mod tests { use crate::aggregate_fn::NumericalAggregateOpts; use crate::aggregate_fn::fns::sum::Sum; use crate::aggregate_fn::fns::sum::sum; - use crate::array_session; use crate::arrays::BoolArray; use crate::dtype::DType; use crate::dtype::Nullability; use crate::dtype::PType; use crate::executor::VortexSessionExecute; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn sum_bool_all_true() -> VortexResult<()> { let arr: BoolArray = [true, true, true].into_iter().collect(); - let result = sum( - &arr.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&arr.into_array(), &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(3)); Ok(()) } @@ -64,10 +65,7 @@ mod tests { #[test] fn sum_bool_mixed() -> VortexResult<()> { let arr: BoolArray = [true, false, true, false, true].into_iter().collect(); - let result = sum( - &arr.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&arr.into_array(), &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(3)); Ok(()) } @@ -75,10 +73,7 @@ mod tests { #[test] fn sum_bool_all_false() -> VortexResult<()> { let arr: BoolArray = [false, false, false].into_iter().collect(); - let result = sum( - &arr.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&arr.into_array(), &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(0)); Ok(()) } @@ -86,10 +81,7 @@ mod tests { #[test] fn sum_bool_with_nulls() -> VortexResult<()> { let arr = BoolArray::from_iter([Some(true), None, Some(true), Some(false)]); - let result = sum( - &arr.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&arr.into_array(), &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(2)); Ok(()) } @@ -97,10 +89,7 @@ mod tests { #[test] fn sum_bool_all_null() -> VortexResult<()> { let arr = BoolArray::from_iter([None::, None, None]); - let result = sum( - &arr.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&arr.into_array(), &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(0)); Ok(()) } @@ -116,7 +105,7 @@ mod tests { #[test] fn sum_bool_finish_resets_state() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Bool(Nullability::NonNullable); let mut acc = Accumulator::try_new(Sum, NumericalAggregateOpts::default(), dtype)?; @@ -147,7 +136,7 @@ mod tests { #[test] fn sum_boolean_from_iter() -> VortexResult<()> { let arr = BoolArray::from_iter([true, false, false, true]).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().as_::(), Some(2)); Ok(()) } diff --git a/vortex-array/src/aggregate_fn/fns/sum/constant.rs b/vortex-array/src/aggregate_fn/fns/sum/constant.rs index b38f15fd14c..f1b21c8b0b2 100644 --- a/vortex-array/src/aggregate_fn/fns/sum/constant.rs +++ b/vortex-array/src/aggregate_fn/fns/sum/constant.rs @@ -95,12 +95,14 @@ pub(crate) fn multiply_constant( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; use crate::aggregate_fn::fns::sum::sum; - use crate::array_session; use crate::arrays::ConstantArray; use crate::dtype::DType; use crate::dtype::DecimalDType; @@ -112,10 +114,12 @@ mod tests { use crate::scalar::DecimalValue; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn sum_constant_unsigned() -> VortexResult<()> { let array = ConstantArray::new(5u64, 10).into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!(result, 50u64.into()); Ok(()) } @@ -123,7 +127,7 @@ mod tests { #[test] fn sum_constant_signed() -> VortexResult<()> { let array = ConstantArray::new(-5i64, 10).into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!(result, (-50i64).into()); Ok(()) } @@ -132,7 +136,7 @@ mod tests { fn sum_constant_nullable_value() -> VortexResult<()> { let array = ConstantArray::new(Scalar::null(DType::Primitive(PType::U32, Nullable)), 10) .into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!(result, Scalar::primitive(0u64, Nullable)); Ok(()) } @@ -140,7 +144,7 @@ mod tests { #[test] fn sum_constant_bool_false() -> VortexResult<()> { let array = ConstantArray::new(false, 10).into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!(result, 0u64.into()); Ok(()) } @@ -148,7 +152,7 @@ mod tests { #[test] fn sum_constant_bool_true() -> VortexResult<()> { let array = ConstantArray::new(true, 10).into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!(result, 10u64.into()); Ok(()) } @@ -156,7 +160,7 @@ mod tests { #[test] fn sum_constant_bool_null() -> VortexResult<()> { let array = ConstantArray::new(Scalar::null(DType::Bool(Nullable)), 10).into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!(result, Scalar::primitive(0u64, Nullable)); Ok(()) } @@ -174,7 +178,7 @@ mod tests { ) .into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!( result.as_decimal().decimal_value(), @@ -190,7 +194,7 @@ mod tests { let array = ConstantArray::new(Scalar::null(DType::Decimal(decimal_dtype, Nullable)), 10) .into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!( result, Scalar::decimal( @@ -215,7 +219,7 @@ mod tests { ) .into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!( result.as_decimal().decimal_value(), Some(DecimalValue::I256(i256::from_i128(99_999_999_900))) @@ -236,7 +240,7 @@ mod tests { ) .into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!( result.as_decimal().decimal_value(), @@ -260,7 +264,7 @@ mod tests { ) .into_array(); - let result = sum(&array, &mut array_session().create_execution_ctx())?; + let result = sum(&array, &mut SESSION.create_execution_ctx())?; assert!(result.is_null()); Ok(()) diff --git a/vortex-array/src/aggregate_fn/fns/sum/decimal.rs b/vortex-array/src/aggregate_fn/fns/sum/decimal.rs index e30bd1f1dfc..799d83b7219 100644 --- a/vortex-array/src/aggregate_fn/fns/sum/decimal.rs +++ b/vortex-array/src/aggregate_fn/fns/sum/decimal.rs @@ -112,9 +112,12 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -125,7 +128,6 @@ mod tests { use crate::aggregate_fn::fns::sum::SumPartial; use crate::aggregate_fn::fns::sum::SumState; use crate::aggregate_fn::fns::sum::sum; - use crate::array_session; use crate::arrays::DecimalArray; use crate::dtype::DType; use crate::dtype::DecimalDType; @@ -137,6 +139,8 @@ mod tests { use crate::scalar::ScalarValue; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// A partial whose running decimal sum is `value` (test-only helper bypassing scalar parsing). fn partial_with_decimal(value: DecimalValue) -> SumPartial { SumPartial { @@ -152,10 +156,7 @@ mod tests { Validity::AllValid, ); - let result = sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&decimal.into_array(), &mut SESSION.create_execution_ctx())?; let expected = Scalar::try_new( DType::Decimal(DecimalDType::new(14, 2), Nullability::NonNullable), @@ -174,10 +175,7 @@ mod tests { Validity::from_iter([true, false, true, true]), ); - let result = sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&decimal.into_array(), &mut SESSION.create_execution_ctx())?; let expected = Scalar::try_new( DType::Decimal(DecimalDType::new(14, 2), Nullable), @@ -196,10 +194,7 @@ mod tests { Validity::AllValid, ); - let result = sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&decimal.into_array(), &mut SESSION.create_execution_ctx())?; let expected = Scalar::try_new( DType::Decimal(DecimalDType::new(14, 2), Nullability::NonNullable), @@ -219,10 +214,7 @@ mod tests { Validity::AllValid, ); - let result = sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&decimal.into_array(), &mut SESSION.create_execution_ctx())?; let expected_sum = near_max as i64 + 500 + 400; let expected = Scalar::try_new( @@ -243,10 +235,7 @@ mod tests { Validity::AllValid, ); - let result = sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&decimal.into_array(), &mut SESSION.create_execution_ctx())?; let expected_sum = (large_val as i128) * 4 + 1; let expected = Scalar::try_new( @@ -266,10 +255,7 @@ mod tests { Validity::AllValid, ); - let result = sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&decimal.into_array(), &mut SESSION.create_execution_ctx())?; let expected = Scalar::try_new( DType::Decimal(DecimalDType::new(16, 4), Nullability::NonNullable), @@ -285,10 +271,7 @@ mod tests { let decimal = DecimalArray::new(buffer![42i32], DecimalDType::new(3, 1), Validity::AllValid); - let result = sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&decimal.into_array(), &mut SESSION.create_execution_ctx())?; let expected = Scalar::try_new( DType::Decimal(DecimalDType::new(13, 1), Nullability::NonNullable), @@ -307,10 +290,7 @@ mod tests { Validity::from_iter([false, false, true, false]), ); - let result = sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&decimal.into_array(), &mut SESSION.create_execution_ctx())?; let expected = Scalar::try_new( DType::Decimal(DecimalDType::new(14, 2), Nullable), @@ -330,10 +310,7 @@ mod tests { Validity::AllValid, ); - let result = sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&decimal.into_array(), &mut SESSION.create_execution_ctx())?; let expected_sum = i256::from_i128(max_val) + i256::from_i128(max_val) + i256::from_i128(max_val); @@ -356,11 +333,8 @@ mod tests { ); assert_eq!( - sum( - &decimal.into_array(), - &mut array_session().create_execution_ctx() - ) - .vortex_expect("operation should succeed in test"), + sum(&decimal.into_array(), &mut SESSION.create_execution_ctx()) + .vortex_expect("operation should succeed in test"), Scalar::null(DType::Decimal(decimal_dtype, Nullable)) ); Ok(()) @@ -455,7 +429,7 @@ mod tests { // Drive accumulate through the vtable directly. let columnar = crate::Columnar::Canonical(crate::Canonical::Decimal(decimal)); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); Sum.accumulate(dtypes.args(&options), &mut state, &columnar, &mut ctx)?; let result = Sum.to_scalar(dtypes.args(&options), &state)?; diff --git a/vortex-array/src/aggregate_fn/fns/sum/grouped.rs b/vortex-array/src/aggregate_fn/fns/sum/grouped.rs index c0b7e42dc44..3d69ffd87c6 100644 --- a/vortex-array/src/aggregate_fn/fns/sum/grouped.rs +++ b/vortex-array/src/aggregate_fn/fns/sum/grouped.rs @@ -154,8 +154,11 @@ fn sum_masked_group( mod tests { #![allow(clippy::cast_possible_truncation)] + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; @@ -165,7 +168,6 @@ mod tests { use crate::aggregate_fn::NumericalAggregateOpts; use crate::aggregate_fn::fns::sum::Sum; use crate::aggregate_fn::fns::sum::sum; - use crate::array_session; use crate::arrays::FixedSizeListArray; use crate::arrays::ListViewArray; use crate::arrays::PrimitiveArray; @@ -177,6 +179,8 @@ mod tests { use crate::dtype::PType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Run a grouped sum through the accumulator. fn grouped_sum_actual(groups: &ArrayRef, elem_dtype: &DType) -> VortexResult { let mut acc = GroupedAccumulator::try_new( @@ -184,7 +188,7 @@ mod tests { NumericalAggregateOpts::default(), elem_dtype.clone(), )?; - acc.accumulate_list(groups, &mut array_session().create_execution_ctx())?; + acc.accumulate_list(groups, &mut SESSION.create_execution_ctx())?; acc.finish() } @@ -198,7 +202,7 @@ mod tests { ) -> VortexResult { use crate::aggregate_fn::AggregateFnVTable; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let sum_dtype = Sum .partial_dtype(&NumericalAggregateOpts::default(), elem_dtype) .expect("sum partial dtype"); @@ -229,7 +233,7 @@ mod tests { ranges: &[(usize, usize)], group_valid: &[bool], ) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let (offsets, sizes) = offsets_sizes(ranges); let validity = if group_valid.iter().all(|&v| v) { Validity::NonNullable @@ -241,7 +245,7 @@ mod tests { #[test] fn listview_matches_reference_unsigned() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::new(buffer![1u32, 2, 3, 4, 5, 6], Validity::NonNullable).into_array(); let elem_dtype = DType::Primitive(PType::U32, NonNullable); @@ -261,7 +265,7 @@ mod tests { #[test] fn listview_out_of_order_offsets_with_null_group() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Offsets are not in group order and a group is null: the group validity must be indexed by // group index, not by element offset. let elements = @@ -283,7 +287,7 @@ mod tests { #[test] fn listview_interior_and_full_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Group 1 has an interior null, group 2 is entirely null, group 3 is empty. let elements = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, None, Some(9)]) @@ -305,7 +309,7 @@ mod tests { #[test] fn listview_overflow_group_is_null() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::new(buffer![i64::MAX, 1, 2, 3], Validity::NonNullable).into_array(); let elem_dtype = DType::Primitive(PType::I64, NonNullable); @@ -339,7 +343,7 @@ mod tests { // Group 0: NaN skipped -> 3.0. Group 1: INF + -INF = NaN. (Avoid array equality here since // NaN != NaN; compare element scalars against the reference path instead.) - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = grouped_sum_reference(&elements, &ranges, &valid, &elem_dtype)?; let g0 = actual.execute_scalar(0, &mut ctx)?; assert_eq!(g0.as_primitive().typed_value::(), Some(3.0)); @@ -375,10 +379,10 @@ mod tests { let mut acc = GroupedAccumulator::try_new(Sum, NumericalAggregateOpts::include_nans(), elem_dtype)?; - acc.accumulate_list(&groups, &mut array_session().create_execution_ctx())?; + acc.accumulate_list(&groups, &mut SESSION.create_execution_ctx())?; let actual = acc.finish()?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Group 0 contains a NaN -> NaN sum; group 1 sums normally. let g0 = actual.execute_scalar(0, &mut ctx)?; assert!(g0.as_primitive().typed_value::().unwrap().is_nan()); @@ -389,7 +393,7 @@ mod tests { #[test] fn fixed_size_overflow_and_nan() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // FixedSize path: first group overflows -> null sum, second sums normally. let elements = PrimitiveArray::new(buffer![i64::MAX, 1, 2, 3], Validity::NonNullable).into_array(); diff --git a/vortex-array/src/aggregate_fn/fns/sum/mod.rs b/vortex-array/src/aggregate_fn/fns/sum/mod.rs index 257777fa964..94c5fa7643d 100644 --- a/vortex-array/src/aggregate_fn/fns/sum/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/sum/mod.rs @@ -442,9 +442,12 @@ fn checked_add_i64(acc: &mut i64, val: i64) -> bool { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; @@ -460,7 +463,6 @@ mod tests { use crate::aggregate_fn::fns::sum::SumPartial; use crate::aggregate_fn::fns::sum::SumState; use crate::aggregate_fn::fns::sum::sum; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -482,11 +484,13 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + // Multi-batch and reset tests #[test] fn sum_multi_batch() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let mut acc = Accumulator::try_new(Sum, NumericalAggregateOpts::default(), dtype)?; @@ -503,7 +507,7 @@ mod tests { #[test] fn sum_finish_resets_state() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let mut acc = Accumulator::try_new(Sum, NumericalAggregateOpts::default(), dtype)?; @@ -568,7 +572,7 @@ mod tests { ) .vortex_expect("operation should succeed in test"); let array = array.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut acc = Accumulator::try_new( Sum, NumericalAggregateOpts::default(), @@ -579,7 +583,7 @@ mod tests { assert_eq!(acc.finish()?, Scalar::primitive(11i64, Nullable)); assert_eq!(array.statistics().get(Stat::Sum), Precision::exact(9i64)); - let sum_without_acc = sum(&array, &mut array_session().create_execution_ctx())?; + let sum_without_acc = sum(&array, &mut SESSION.create_execution_ctx())?; assert_eq!(sum_without_acc, Scalar::primitive(9i64, Nullable)); Ok(()) } @@ -597,7 +601,7 @@ mod tests { array.dtype().clone(), )?; accumulator.combine_partials(&Scalar::primitive(acc, Nullable))?; - accumulator.accumulate(&array, &mut array_session().create_execution_ctx())?; + accumulator.accumulate(&array, &mut SESSION.create_execution_ctx())?; let result = accumulator.finish()?; assert_eq!( f64::try_from(&result).vortex_expect("operation should succeed in test"), @@ -614,13 +618,13 @@ mod tests { NumericalAggregateOpts::default(), elem_dtype.clone(), )?; - acc.accumulate_list(groups, &mut array_session().create_execution_ctx())?; + acc.accumulate_list(groups, &mut SESSION.create_execution_ctx())?; acc.finish() } #[test] fn grouped_sum_fixed_size_list() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::new(buffer![1i32, 2, 3, 4, 5, 6], Validity::NonNullable).into_array(); let groups = FixedSizeListArray::try_new(elements, 3, Validity::NonNullable, 2)?; @@ -635,7 +639,7 @@ mod tests { #[test] fn grouped_sum_with_null_elements() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, Some(5), Some(6)]) .into_array(); @@ -651,7 +655,7 @@ mod tests { #[test] fn grouped_sum_with_null_group() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::new(buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9], Validity::NonNullable) .into_array(); @@ -669,7 +673,7 @@ mod tests { #[test] fn grouped_sum_all_null_elements_in_group() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_option_iter([None::, None, Some(3), Some(4)]).into_array(); let groups = FixedSizeListArray::try_new(elements, 2, Validity::NonNullable, 2)?; @@ -684,7 +688,7 @@ mod tests { #[test] fn grouped_sum_bool() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements: BoolArray = [true, false, true, true, true, true].into_iter().collect(); let groups = FixedSizeListArray::try_new(elements.into_array(), 3, Validity::NonNullable, 2)?; @@ -699,7 +703,7 @@ mod tests { #[test] fn grouped_sum_finish_resets() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elem_dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let mut acc = GroupedAccumulator::try_new(Sum, NumericalAggregateOpts::default(), elem_dtype)?; @@ -725,7 +729,7 @@ mod tests { #[test] fn grouped_sum_listview_out_of_order_offsets_with_null_group() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::new(buffer![100i32, 200, 300], Validity::NonNullable).into_array(); let offsets = PrimitiveArray::new(buffer![2i32, 0, 1], Validity::NonNullable).into_array(); @@ -762,10 +766,7 @@ mod tests { dtype, )?; - let result = sum( - &chunked.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&chunked.into_array(), &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().as_::(), Some(20.8)); Ok(()) } @@ -776,10 +777,7 @@ mod tests { let chunk2 = PrimitiveArray::from_option_iter::(vec![None, None]); let dtype = chunk1.dtype().clone(); let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?; - let result = sum( - &chunked.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&chunked.into_array(), &mut SESSION.create_execution_ctx())?; assert_eq!(result, Scalar::primitive(0f64, Nullable)); Ok(()) } @@ -799,10 +797,7 @@ mod tests { dtype, )?; - let result = sum( - &chunked.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&chunked.into_array(), &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().as_::(), Some(36.0)); Ok(()) } @@ -814,10 +809,7 @@ mod tests { let dtype = chunk1.dtype().clone(); let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?; - let result = sum( - &chunked.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&chunked.into_array(), &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().as_::(), Some(1)); Ok(()) } @@ -846,10 +838,7 @@ mod tests { dtype, )?; - let result = sum( - &chunked.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&chunked.into_array(), &mut SESSION.create_execution_ctx())?; let decimal_result = result.as_decimal(); assert_eq!( decimal_result.decimal_value(), @@ -882,10 +871,7 @@ mod tests { dtype, )?; - let result = sum( - &chunked.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&chunked.into_array(), &mut SESSION.create_execution_ctx())?; let decimal_result = result.as_decimal(); assert_eq!( decimal_result.decimal_value(), @@ -916,10 +902,7 @@ mod tests { let dtype = chunk1.dtype().clone(); let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?; - let result = sum( - &chunked.into_array(), - &mut array_session().create_execution_ctx(), - )?; + let result = sum(&chunked.into_array(), &mut SESSION.create_execution_ctx())?; let decimal_result = result.as_decimal(); assert_eq!( decimal_result.decimal_value(), diff --git a/vortex-array/src/aggregate_fn/fns/sum/primitive.rs b/vortex-array/src/aggregate_fn/fns/sum/primitive.rs index de035054950..fe61454a914 100644 --- a/vortex-array/src/aggregate_fn/fns/sum/primitive.rs +++ b/vortex-array/src/aggregate_fn/fns/sum/primitive.rs @@ -180,8 +180,11 @@ fn accumulate_primitive_valid( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -190,7 +193,6 @@ mod tests { use crate::aggregate_fn::NumericalAggregateOpts; use crate::aggregate_fn::fns::sum::Sum; use crate::aggregate_fn::fns::sum::sum; - use crate::array_session; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; use crate::dtype::DType; @@ -203,10 +205,12 @@ mod tests { use crate::scalar::ScalarValue; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn sum_i32() -> VortexResult<()> { let arr = PrimitiveArray::new(buffer![1i32, 2, 3, 4], Validity::NonNullable).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(10)); Ok(()) } @@ -214,7 +218,7 @@ mod tests { #[test] fn sum_u8() -> VortexResult<()> { let arr = PrimitiveArray::new(buffer![10u8, 20, 30], Validity::NonNullable).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(60)); Ok(()) } @@ -223,7 +227,7 @@ mod tests { fn sum_f64() -> VortexResult<()> { let arr = PrimitiveArray::new(buffer![1.5f64, 2.5, 3.0], Validity::NonNullable).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(7.0)); Ok(()) } @@ -231,7 +235,7 @@ mod tests { #[test] fn sum_with_nulls() -> VortexResult<()> { let arr = PrimitiveArray::from_option_iter([Some(2i32), None, Some(4)]).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(6)); Ok(()) } @@ -251,7 +255,7 @@ mod tests { Some(6), ]) .into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(21)); Ok(()) } @@ -259,7 +263,7 @@ mod tests { #[test] fn sum_all_null() -> VortexResult<()> { let arr = PrimitiveArray::from_option_iter([None::, None, None]).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(0)); Ok(()) } @@ -267,7 +271,7 @@ mod tests { #[test] fn sum_all_invalid_float() -> VortexResult<()> { let arr = PrimitiveArray::from_option_iter::([None, None, None]).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result, Scalar::primitive(0f64, Nullable)); Ok(()) } @@ -275,7 +279,7 @@ mod tests { #[test] fn sum_buffer_i32() -> VortexResult<()> { let arr = buffer![1, 1, 1, 1].into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().as_::(), Some(4)); Ok(()) } @@ -283,7 +287,7 @@ mod tests { #[test] fn sum_buffer_f64() -> VortexResult<()> { let arr = buffer![1., 1., 1., 1.].into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().as_::(), Some(4.)); Ok(()) } @@ -313,7 +317,7 @@ mod tests { Validity::NonNullable, ) .into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(6.0)); Ok(()) } @@ -322,7 +326,7 @@ mod tests { fn sum_f32_with_nan() -> VortexResult<()> { let arr = PrimitiveArray::new(buffer![1.0f32, f32::NAN, 4.0], Validity::NonNullable).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(5.0)); Ok(()) } @@ -331,7 +335,7 @@ mod tests { fn sum_f64_with_nan_and_nulls() -> VortexResult<()> { let arr = PrimitiveArray::from_option_iter([Some(1.0f64), None, Some(f64::NAN), Some(3.0)]) .into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(4.0)); Ok(()) } @@ -340,7 +344,7 @@ mod tests { fn sum_all_nan() -> VortexResult<()> { let arr = PrimitiveArray::new(buffer![f64::NAN, f64::NAN], Validity::NonNullable).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert_eq!(result.as_primitive().typed_value::(), Some(0.0)); Ok(()) } @@ -351,7 +355,7 @@ mod tests { options: NumericalAggregateOpts, ) -> VortexResult { let mut acc = Accumulator::try_new(Sum, options, arr.dtype().clone())?; - acc.accumulate(arr, &mut array_session().create_execution_ctx())?; + acc.accumulate(arr, &mut SESSION.create_execution_ctx())?; acc.finish() } @@ -418,7 +422,7 @@ mod tests { Validity::NonNullable, ) .into_array(); - let acc = sum(&batch, &mut array_session().create_execution_ctx())?; + let acc = sum(&batch, &mut SESSION.create_execution_ctx())?; // INFINITY + NEG_INFINITY = NaN, which is treated as saturated assert!(acc.as_primitive().typed_value::().unwrap().is_nan()); @@ -427,7 +431,7 @@ mod tests { NumericalAggregateOpts::default(), DType::Primitive(PType::F64, Nullability::NonNullable), )?; - acc.accumulate(&batch, &mut array_session().create_execution_ctx())?; + acc.accumulate(&batch, &mut SESSION.create_execution_ctx())?; assert!(acc.is_saturated()); Ok(()) } @@ -435,7 +439,7 @@ mod tests { #[test] fn sum_checked_overflow() -> VortexResult<()> { let arr = PrimitiveArray::new(buffer![i64::MAX, 1i64], Validity::NonNullable).into_array(); - let result = sum(&arr, &mut array_session().create_execution_ctx())?; + let result = sum(&arr, &mut SESSION.create_execution_ctx())?; assert!(result.is_null()); Ok(()) } @@ -448,7 +452,7 @@ mod tests { let batch = PrimitiveArray::new(buffer![i64::MAX, 1i64], Validity::NonNullable).into_array(); - acc.accumulate(&batch, &mut array_session().create_execution_ctx())?; + acc.accumulate(&batch, &mut SESSION.create_execution_ctx())?; assert!(acc.is_saturated()); // finish resets state, clearing saturation diff --git a/vortex-array/src/aggregate_fn/fns/sum_v2/tests.rs b/vortex-array/src/aggregate_fn/fns/sum_v2/tests.rs index 46ab9e70615..20eb19abd1c 100644 --- a/vortex-array/src/aggregate_fn/fns/sum_v2/tests.rs +++ b/vortex-array/src/aggregate_fn/fns/sum_v2/tests.rs @@ -1,10 +1,13 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use prost::Message; use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use super::SumV2; use super::sum_v2; @@ -22,7 +25,6 @@ use crate::aggregate_fn::DynGroupedAccumulator; use crate::aggregate_fn::GroupedAccumulator; use crate::aggregate_fn::NumericalAggregateOpts; use crate::aggregate_fn::fns::sum::Sum; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -44,9 +46,11 @@ use crate::scalar::Scalar; use crate::scalar::ScalarValue; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn sum_with_options(array: &ArrayRef, options: NumericalAggregateOpts) -> VortexResult { let mut accumulator = Accumulator::try_new(SumV2, options, array.dtype().clone())?; - accumulator.accumulate(array, &mut array_session().create_execution_ctx())?; + accumulator.accumulate(array, &mut SESSION.create_execution_ctx())?; accumulator.finish() } @@ -70,7 +74,7 @@ fn distinct_id_and_struct_partial() -> VortexResult<()> { let proto = aggregate.serialize_proto()?; let decoded = pb::AggregateFn::decode(proto.encode_to_vec().as_slice())?; - let round_tripped = AggregateFnRef::from_proto(&decoded, &array_session())?; + let round_tripped = AggregateFnRef::from_proto(&decoded, &SESSION)?; assert_eq!(round_tripped, aggregate); Ok(()) } @@ -112,7 +116,7 @@ fn legacy_sum_is_unchanged() -> VortexResult<()> { .into_array() )] fn all_null_is_null(#[case] array: ArrayRef) -> VortexResult<()> { - assert!(sum_v2(&array, &mut array_session().create_execution_ctx())?.is_null()); + assert!(sum_v2(&array, &mut SESSION.create_execution_ctx())?.is_null()); Ok(()) } @@ -120,7 +124,7 @@ fn all_null_is_null(#[case] array: ArrayRef) -> VortexResult<()> { fn valid_zero_is_not_empty() -> VortexResult<()> { let zeros = PrimitiveArray::from_iter([0i32, 0]).into_array(); assert_eq!( - sum_v2(&zeros, &mut array_session().create_execution_ctx())? + sum_v2(&zeros, &mut SESSION.create_execution_ctx())? .as_primitive() .typed_value::(), Some(0) @@ -128,7 +132,7 @@ fn valid_zero_is_not_empty() -> VortexResult<()> { let false_values = BoolArray::from_iter([false, false]).into_array(); assert_eq!( - sum_v2(&false_values, &mut array_session().create_execution_ctx())? + sum_v2(&false_values, &mut SESSION.create_execution_ctx())? .as_primitive() .typed_value::(), Some(0) @@ -141,7 +145,7 @@ fn all_nan_is_nonempty_zero_when_skipped() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![f64::NAN, f64::NAN], Validity::NonNullable).into_array(); assert_eq!( - sum_v2(&array, &mut array_session().create_execution_ctx())? + sum_v2(&array, &mut SESSION.create_execution_ctx())? .as_primitive() .typed_value::(), Some(0.0) @@ -165,7 +169,7 @@ fn ignores_ambiguous_legacy_sum_stat() -> VortexResult<()> { .statistics() .set(Stat::Sum, Precision::Exact(ScalarValue::from(0i64))); - assert!(sum_v2(&array, &mut array_session().create_execution_ctx())?.is_null()); + assert!(sum_v2(&array, &mut SESSION.create_execution_ctx())?.is_null()); Ok(()) } @@ -174,7 +178,7 @@ fn overflow_is_explicit_and_absorbing() -> VortexResult<()> { let dtype = DType::Primitive(PType::I64, Nullability::NonNullable); let mut accumulator = Accumulator::try_new(SumV2, NumericalAggregateOpts::default(), dtype)?; let batch = PrimitiveArray::new(buffer![i64::MAX, 1, 7], Validity::NonNullable).into_array(); - accumulator.accumulate(&batch, &mut array_session().create_execution_ctx())?; + accumulator.accumulate(&batch, &mut SESSION.create_execution_ctx())?; assert!(accumulator.is_saturated()); let partial = accumulator.partial_scalar()?; @@ -210,7 +214,7 @@ fn empty_chunk_is_a_merge_identity() -> VortexResult<()> { .into_array(); assert_eq!( - sum_v2(&chunked, &mut array_session().create_execution_ctx())? + sum_v2(&chunked, &mut SESSION.create_execution_ctx())? .as_primitive() .typed_value::(), Some(7) @@ -228,7 +232,7 @@ fn accumulated(value: i64, ctx: &mut ExecutionCtx) -> VortexResult VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I64, Nullability::NonNullable); let new_accumulator = || Accumulator::try_new(SumV2, NumericalAggregateOpts::default(), dtype.clone()); @@ -257,7 +261,7 @@ fn merge_from_empty_is_identity() -> VortexResult<()> { #[test] fn merge_from_overflow_is_absorbing() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I64, Nullability::NonNullable); let options = NumericalAggregateOpts::default(); @@ -304,7 +308,7 @@ fn merge_from_overflow_is_absorbing() -> VortexResult<()> { #[test] fn grouped_primitive_tracks_empty_overflow_and_null_groups() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_option_iter([Some(5i64), None, Some(i64::MAX), Some(1)]).into_array(); let groups = ListViewArray::try_new( @@ -320,7 +324,7 @@ fn grouped_primitive_tracks_empty_overflow_and_null_groups() -> VortexResult<()> NumericalAggregateOpts::default(), DType::Primitive(PType::I64, Nullable), )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); accumulator.accumulate_list(&groups, &mut ctx)?; let result = accumulator.finish()?; @@ -332,7 +336,7 @@ fn grouped_primitive_tracks_empty_overflow_and_null_groups() -> VortexResult<()> #[test] fn grouped_bool_fallback_tracks_empty_groups() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = BoolArray::from_iter([Some(true), Some(true), None, None]).into_array(); let groups = ListViewArray::try_new( elements, @@ -347,7 +351,7 @@ fn grouped_bool_fallback_tracks_empty_groups() -> VortexResult<()> { NumericalAggregateOpts::default(), DType::Bool(Nullable), )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); accumulator.accumulate_list(&groups, &mut ctx)?; let result = accumulator.finish()?; @@ -387,10 +391,6 @@ fn finalize_struct_applies_partial_and_struct_validity( AggregateDTypes::try_new(&SumV2, &options, DType::Primitive(PType::I64, Nullable))?; let result = SumV2.finalize(dtypes.args(&options), partials)?; let expected = PrimitiveArray::from_option_iter(expected).into_array(); - assert_arrays_eq!( - &result, - &expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(&result, &expected, &mut SESSION.create_execution_ctx()); Ok(()) } diff --git a/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/mod.rs b/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/mod.rs index 43ce0d25cf0..285d1948960 100644 --- a/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/mod.rs @@ -468,6 +468,7 @@ pub(crate) fn packed_bit_buffer_size_in_bytes(len: usize) -> VortexResult { #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use vortex_buffer::Buffer; use vortex_buffer::ByteBuffer; @@ -475,6 +476,7 @@ mod tests { use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; @@ -488,7 +490,6 @@ mod tests { use crate::aggregate_fn::fns::uncompressed_size_in_bytes::UncompressedSizeInBytes; use crate::aggregate_fn::fns::uncompressed_size_in_bytes::UncompressedSizeOpts; use crate::aggregate_fn::fns::uncompressed_size_in_bytes::uncompressed_size_in_bytes; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -520,6 +521,8 @@ mod tests { use crate::scalar::ScalarValue; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// The size the array occupies once rebuilt through the canonical builders, which is the /// layout [`UncompressedSizeInBytes`] is defined against: the builders normalize physical /// widths that the input array is free to choose differently, picking the smallest decimal @@ -528,7 +531,7 @@ mod tests { /// Builders no longer canonicalize their children, so the finished array is only canonical at /// the top level - recursively canonicalize it before measuring. fn materialized_uncompressed_size_in_bytes(array: &ArrayRef) -> u64 { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = builder_with_capacity_in( array.dtype(), array.len(), @@ -551,7 +554,7 @@ mod tests { } fn aggregate_with(array: &ArrayRef, opts: UncompressedSizeOpts) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut acc = Accumulator::try_new(UncompressedSizeInBytes, opts, array.dtype().clone())?; acc.accumulate(array, &mut ctx)?; acc.finish()? @@ -700,7 +703,7 @@ mod tests { #[test] fn list_matches_materialized_size() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::new(buffer![1i32, 2, 3, 4], Validity::NonNullable).into_array(); let offsets = buffer![2u32, 0].into_array(); @@ -710,7 +713,7 @@ mod tests { // The lists are out of order and leave element 1 unreferenced, so compare against the // exact layout rather than a builder round-trip. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let exact = array .clone() .execute::(&mut ctx)? @@ -829,7 +832,7 @@ mod tests { #[test] fn exact_result_is_cached_as_exact_stat() -> VortexResult<()> { let sliced = views_into_shared_page(0..10)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let size = uncompressed_size_in_bytes(&sliced, UncompressedSizeOpts::exact(), &mut ctx)?; @@ -844,7 +847,7 @@ mod tests { #[test] fn inexact_result_is_cached_as_upper_bound() -> VortexResult<()> { let sliced = views_into_shared_page(0..10)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let inexact = uncompressed_size_in_bytes(&sliced, UncompressedSizeOpts::inexact(), &mut ctx)?; @@ -970,7 +973,7 @@ mod tests { fn variant_stat_is_unsupported() -> VortexResult<()> { let child = ConstantArray::new(Scalar::variant(Scalar::from(42i32)), 3).into_array(); let array = VariantArray::try_new(child, None)?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( array @@ -1025,7 +1028,7 @@ mod tests { #[test] fn helper_caches_result() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let size = uncompressed_size_in_bytes(&array, UncompressedSizeOpts::exact(), &mut ctx)?; diff --git a/vortex-array/src/aggregate_fn/proto.rs b/vortex-array/src/aggregate_fn/proto.rs index e1ee8739e7c..684d582ce21 100644 --- a/vortex-array/src/aggregate_fn/proto.rs +++ b/vortex-array/src/aggregate_fn/proto.rs @@ -59,6 +59,8 @@ impl AggregateFnRef { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use prost::Message; use rstest::rstest; use vortex_error::VortexResult; @@ -82,6 +84,12 @@ mod tests { use crate::proto::expr as pb; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(|| { + let session = VortexSession::empty(); + session.aggregate_fns().register(TestAgg); + session + }); + /// A minimal serializable aggregate function used solely to exercise the serde round-trip. #[derive(Clone, Debug)] struct TestAgg; @@ -184,15 +192,12 @@ mod tests { #[test] fn aggregate_fn_serde() { - let session = crate::array_session(); - session.aggregate_fns().register(TestAgg); - let agg_fn = TestAgg.bind(EmptyOptions); let serialized = agg_fn.serialize_proto().unwrap(); let buf = serialized.encode_to_vec(); let deserialized_proto = pb::AggregateFn::decode(buf.as_slice()).unwrap(); - let deserialized = AggregateFnRef::from_proto(&deserialized_proto, &session).unwrap(); + let deserialized = AggregateFnRef::from_proto(&deserialized_proto, &SESSION).unwrap(); assert_eq!(deserialized, agg_fn); } @@ -205,7 +210,7 @@ mod tests { fn numeric_aggregate_options_round_trip( #[case] options: NumericalAggregateOpts, ) -> VortexResult<()> { - let session = crate::array_session(); + let session = VortexSession::empty(); let agg_fn = Sum.bind(options); let proto = agg_fn.serialize_proto()?; diff --git a/vortex-array/src/aggregate_fn/storage_pushdown.rs b/vortex-array/src/aggregate_fn/storage_pushdown.rs index 701cdd76d17..2e8d5123693 100644 --- a/vortex-array/src/aggregate_fn/storage_pushdown.rs +++ b/vortex-array/src/aggregate_fn/storage_pushdown.rs @@ -69,6 +69,7 @@ use crate::scalar::Scalar; /// /// ``` /// # use vortex_array::IntoArray; +/// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; /// # use vortex_array::aggregate_fn::Accumulator; /// # use vortex_array::aggregate_fn::DynAccumulator; @@ -83,7 +84,7 @@ use crate::scalar::Scalar; /// # use vortex_array::extension::datetime::TimeUnit; /// # use vortex_array::extension::datetime::Timestamp; /// # fn main() -> vortex_error::VortexResult<()> { -/// let session = vortex_array::array_session(); +/// let session = VortexSession::empty(); /// /// // Register `vortex.is_sorted[vortex.timestamp]`. /// let is_sorted = ExtensionStoragePushdown::new(IsSorted, Timestamp); @@ -315,8 +316,11 @@ impl AggregateFnVTable for ExtensionStorageP #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::ExtensionStoragePushdown; use crate::IntoArray; @@ -340,9 +344,11 @@ mod tests { use crate::extension::datetime::Timestamp; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn pushes_down_into_storage() -> VortexResult<()> { - let session = crate::array_session(); + let session = VortexSession::empty(); let aggregate = ExtensionStoragePushdown::new(MinMax, Timestamp); session.aggregate_fns().register(aggregate.clone()); assert!( @@ -378,8 +384,7 @@ mod tests { #[test] fn combines_flushed_partials() -> VortexResult<()> { - let session = crate::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ext_dtype = Timestamp::new(TimeUnit::Milliseconds, Nullability::Nullable).erased(); let batch = |values: [Option; 2]| { ExtensionArray::new( @@ -412,8 +417,7 @@ mod tests { #[test] fn accumulates_constant_batches() -> VortexResult<()> { - let session = crate::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ext_dtype = Timestamp::new(TimeUnit::Milliseconds, Nullability::Nullable).erased(); let constant = |value: i64| { ConstantArray::new( @@ -460,7 +464,7 @@ mod tests { #[test] fn default_session_registers_temporal_order_aggregates() { - let session = crate::array_session(); + let session = VortexSession::empty(); let aggregate_fns = session.aggregate_fns(); for id in [ ExtensionStoragePushdown::new(IsSorted, Date).id(), @@ -487,8 +491,7 @@ mod tests { #[case] strict: bool, #[case] expected: bool, ) -> VortexResult<()> { - let session = crate::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ext_dtype = Timestamp::new(TimeUnit::Milliseconds, Nullability::Nullable).erased(); let array = ExtensionArray::new( ext_dtype.clone(), @@ -509,8 +512,7 @@ mod tests { #[test] fn min_max_over_dates_matches_storage() -> VortexResult<()> { - let session = crate::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ext_dtype = Date::new(TimeUnit::Days, Nullability::Nullable).erased(); let storage = PrimitiveArray::from_option_iter([Some(20i32), None, Some(-3), Some(7)]).into_array(); diff --git a/vortex-array/src/array/erased.rs b/vortex-array/src/array/erased.rs index 7f804c6c865..f630d42a4f8 100644 --- a/vortex-array/src/array/erased.rs +++ b/vortex-array/src/array/erased.rs @@ -277,11 +277,12 @@ impl ArrayRef { /// many reads of the same array use [`Self::repeated_probe`]. /// /// ``` + /// use vortex_session::VortexSession; /// use vortex_array::{IntoArray, VortexSessionExecute}; /// use vortex_array::arrays::PrimitiveArray; /// /// let array = PrimitiveArray::from_iter([10i32, 20, 30]).into_array(); - /// let mut ctx = vortex_array::array_session().create_execution_ctx(); + /// let mut ctx = VortexSession::empty().create_execution_ctx(); /// assert_eq!(array.probe().execute_scalar(2, &mut ctx)?, 30i32.into()); /// # Ok::<(), vortex_error::VortexError>(()) /// ``` @@ -294,11 +295,12 @@ impl ArrayRef { /// probe and child probes between reads. /// /// ``` + /// use vortex_session::VortexSession; /// use vortex_array::{IntoArray, VortexSessionExecute}; /// use vortex_array::arrays::PrimitiveArray; /// /// let array = PrimitiveArray::from_iter([10i32, 20, 30]).into_array(); - /// let mut ctx = vortex_array::array_session().create_execution_ctx(); + /// let mut ctx = VortexSession::empty().create_execution_ctx(); /// let mut probe = array.repeated_probe(); /// assert_eq!(probe.execute_scalar(2, &mut ctx)?, 30i32.into()); /// assert_eq!(probe.execute_scalar(0, &mut ctx)?, 10i32.into()); diff --git a/vortex-array/src/array/probe/array.rs b/vortex-array/src/array/probe/array.rs index 8719eb2e22e..57a908905a4 100644 --- a/vortex-array/src/array/probe/array.rs +++ b/vortex-array/src/array/probe/array.rs @@ -281,8 +281,11 @@ pub(super) fn child_of(parent: &ArrayRef, slot: usize) -> VortexResult = LazyLock::new(VortexSession::empty); + fn nullable_ints() -> ArrayRef { PrimitiveArray::from_option_iter([Some(10i32), None, Some(30)]).into_array() } @@ -310,7 +315,7 @@ mod tests { #[test] fn once_probe_checks_bounds_and_nulls() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = nullable_ints(); check_reads(array.probe(), &mut ctx) } @@ -319,7 +324,7 @@ mod tests { /// validity before `scalar_at`. #[test] fn default_probe_scalar_resolves_nulls() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = BoolArray::from_iter([Some(true), None, Some(false)]).into_array(); check_bool_reads(array.probe(), &mut ctx)?; check_bool_reads(array.repeated_probe().as_probe(), &mut ctx) @@ -336,7 +341,7 @@ mod tests { /// dtype, on both the one-off and the retained path. #[test] fn wrapper_passes_child_nulls_through() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let codes = PrimitiveArray::from_iter([0u32, 1, 0, 2]).into_array(); let values = PrimitiveArray::from_option_iter([Some(7i64), None, Some(9)]).into_array(); let array = DictArray::try_new(codes, values)?.into_array(); @@ -357,7 +362,7 @@ mod tests { /// validity and scalar reads on both, sliced or not. #[test] fn dict_with_nullable_codes_and_values() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let codes = PrimitiveArray::from_option_iter([Some(0u32), None, Some(1), Some(2), None]) .into_array(); let values = PrimitiveArray::from_option_iter([Some(7i64), None, Some(9)]).into_array(); @@ -384,7 +389,7 @@ mod tests { #[test] fn state_validity_follows_read_policy() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = nullable_ints(); let typed = array .as_opt::() @@ -409,7 +414,7 @@ mod tests { #[test] fn once_state_reads_children_without_retaining() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = struct_of_two_fields()?; let typed = array .as_opt::() diff --git a/vortex-array/src/array/probe/repeated.rs b/vortex-array/src/array/probe/repeated.rs index 40772273d8c..da0669f80a9 100644 --- a/vortex-array/src/array/probe/repeated.rs +++ b/vortex-array/src/array/probe/repeated.rs @@ -201,8 +201,11 @@ pub(super) fn child_probe<'s>( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use super::*; use crate::VortexSessionExecute; @@ -212,6 +215,8 @@ mod tests { use crate::arrays::Struct; use crate::arrays::StructArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn nullable_ints() -> ArrayRef { PrimitiveArray::from_option_iter([Some(10i32), None, Some(30)]).into_array() } @@ -229,7 +234,7 @@ mod tests { #[test] fn repeated_probe_initializes_lazily_and_outlives_handle() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = nullable_ints(); let mut probe = RepeatedArrayProbe::new(array.clone()); drop(array); @@ -244,7 +249,7 @@ mod tests { #[test] fn repeated_probe_resolves_uniform_validity_once() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::from_option_iter([Some(1i32), Some(2)]).into_array(); let mut probe = array.repeated_probe(); assert!(probe.execute_is_valid(1, &mut ctx)?); @@ -259,7 +264,7 @@ mod tests { #[test] fn validity_and_scalar_reads_share_the_validity_slot() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut probe = nullable_ints().repeated_probe(); assert!(!probe.execute_is_valid(1, &mut ctx)?); let Some(ResolvedValidity::Array(validity)) = @@ -278,7 +283,7 @@ mod tests { #[test] fn repeated_probe_reads_null_rows_through_encoding() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::from_option_iter([Some(1i32), None]).into_array(); let mut probe = array.repeated_probe(); assert!(probe.execute_scalar(1, &mut ctx)?.is_null()); @@ -289,7 +294,7 @@ mod tests { #[test] fn repeated_state_creates_children_on_demand() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = struct_of_two_fields()?; let typed = array .as_opt::() diff --git a/vortex-array/src/array/typed.rs b/vortex-array/src/array/typed.rs index 1446afc217c..a5d284a07d8 100644 --- a/vortex-array/src/array/typed.rs +++ b/vortex-array/src/array/typed.rs @@ -548,19 +548,23 @@ impl From> for ArrayRef { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; + use vortex_session::VortexSession; use super::Array; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Primitive; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn typed_array_into_parts_roundtrips() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable); let expected = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable); @@ -572,7 +576,7 @@ mod tests { #[test] fn typed_array_try_into_parts_requires_unique_owner() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable); let alias = array.clone(); diff --git a/vortex-array/src/arrays/bool/array.rs b/vortex-array/src/arrays/bool/array.rs index 0ece3025322..d72a4b439e5 100644 --- a/vortex-array/src/arrays/bool/array.rs +++ b/vortex-array/src/arrays/bool/array.rs @@ -55,7 +55,8 @@ pub struct BoolSlots { /// ``` /// # fn main() -> vortex_error::VortexResult<()> { /// use vortex_array::arrays::BoolArray; -/// use vortex_array::{IntoArray, array_session, VortexSessionExecute}; +/// use vortex_array::{IntoArray, VortexSessionExecute}; +/// use vortex_session::VortexSession; /// /// // Create from iterator using FromIterator impl /// let array: BoolArray = [true, false, true, false].into_iter().collect(); @@ -65,7 +66,7 @@ pub struct BoolSlots { /// assert_eq!(sliced.len(), 2); /// /// // Access individual values -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// let value = array.execute_scalar(0, &mut ctx).unwrap(); /// assert_eq!(value, true.into()); /// # Ok(()) @@ -363,6 +364,7 @@ impl IntoArray for BitBufferMut { mod tests { use std::iter::once; use std::iter::repeat_n; + use std::sync::LazyLock; use vortex_buffer::Alignment; use vortex_buffer::BitBuffer; @@ -370,10 +372,10 @@ mod tests { use vortex_buffer::ByteBuffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::PrimitiveArray; use crate::arrays::bool::BoolArrayExt; @@ -382,9 +384,11 @@ mod tests { use crate::patches::Patches; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn bool_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from_iter([true, false, true]); let scalar = bool::try_from(&arr.execute_scalar(0, &mut ctx).unwrap()).unwrap(); @@ -393,7 +397,7 @@ mod tests { #[test] fn test_all_some_iter() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from_iter([Some(true), Some(false)]); @@ -407,7 +411,7 @@ mod tests { #[test] fn test_bool_from_iter() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from_iter([Some(true), Some(true), None, Some(false), None]); let scalar = bool::try_from(&arr.execute_scalar(0, &mut ctx).unwrap()).unwrap(); @@ -428,7 +432,7 @@ mod tests { #[test] fn patch_sliced_bools() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from(BitBuffer::new_set(12)); let sliced = arr.slice(4..12).unwrap(); assert_arrays_eq!(sliced, BoolArray::from_iter([true; 8]), &mut ctx); @@ -467,7 +471,7 @@ mod tests { #[test] fn slice_array_in_middle() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from(BitBuffer::new_set(16)); let sliced = arr.slice(4..12).unwrap(); assert_arrays_eq!(sliced, BoolArray::from_iter([true; 8]), &mut ctx); @@ -483,7 +487,7 @@ mod tests { let sliced = array.slice(9..15)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( sliced, BoolArray::from_iter([false, false, true, false, true, true]), @@ -494,7 +498,7 @@ mod tests { #[test] fn patch_bools_owned() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from(BitBuffer::new_set(16)); let buf_ptr = arr.to_bit_buffer().inner().as_ptr(); @@ -518,7 +522,7 @@ mod tests { #[test] fn patch_sliced_bools_offset() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from(BitBuffer::new_set(15)); let sliced = arr.slice(4..15).unwrap(); assert_arrays_eq!(sliced, BoolArray::from_iter([true; 11]), &mut ctx); diff --git a/vortex-array/src/arrays/bool/compact.rs b/vortex-array/src/arrays/bool/compact.rs index 3eb416d8176..aa5c00579f3 100644 --- a/vortex-array/src/arrays/bool/compact.rs +++ b/vortex-array/src/arrays/bool/compact.rs @@ -27,19 +27,23 @@ impl BoolArray { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::BitBuffer; use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::Canonical; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::assert_arrays_eq; use crate::buffer::BufferHandle; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(0, 16, Validity::NonNullable)] #[case(0, 13, Validity::NonNullable)] @@ -51,7 +55,7 @@ mod tests { #[case] len: usize, #[case] validity: Validity, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bytes: ByteBuffer = (0..64u8).collect(); let handle = BufferHandle::new_host(bytes.clone()); @@ -66,7 +70,7 @@ mod tests { #[test] fn canonical_compact_trims_bits() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let handle = BufferHandle::new_host((0..64u8).collect()); let array = BoolArray::try_new_from_handle(handle, 0, 20, Validity::NonNullable)?; diff --git a/vortex-array/src/arrays/bool/compute/cast.rs b/vortex-array/src/arrays/bool/compute/cast.rs index fa9691c130d..af98c78909c 100644 --- a/vortex-array/src/arrays/bool/compute/cast.rs +++ b/vortex-array/src/arrays/bool/compute/cast.rs @@ -93,7 +93,7 @@ mod tests { use crate::dtype::Nullability; use crate::dtype::PType; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn try_cast_bool_success() { diff --git a/vortex-array/src/arrays/bool/compute/fill_null.rs b/vortex-array/src/arrays/bool/compute/fill_null.rs index 5fa18299106..94966f2e829 100644 --- a/vortex-array/src/arrays/bool/compute/fill_null.rs +++ b/vortex-array/src/arrays/bool/compute/fill_null.rs @@ -43,13 +43,15 @@ impl FillNullKernel for Bool { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::BitBuffer; use vortex_buffer::bitbuffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::bool::BoolArrayExt; use crate::builtins::ArrayBuiltins; @@ -58,11 +60,13 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(true, bitbuffer![true, true, false, true])] #[case(false, bitbuffer![true, false, false, false])] fn bool_fill_null(#[case] fill_value: bool, #[case] expected: BitBuffer) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bool_array = BoolArray::new( BitBuffer::from_iter([true, true, false, false]), Validity::from_iter([true, false, true, false]), diff --git a/vortex-array/src/arrays/bool/compute/filter.rs b/vortex-array/src/arrays/bool/compute/filter.rs index dc495048df1..3ada8ea438c 100644 --- a/vortex-array/src/arrays/bool/compute/filter.rs +++ b/vortex-array/src/arrays/bool/compute/filter.rs @@ -302,21 +302,25 @@ fn pext_byte_lut(src: u64, mask: u64) -> u64 { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use itertools::Itertools; use rstest::rstest; use vortex_mask::Mask; + use vortex_session::VortexSession; use super::*; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::assert_arrays_eq; use crate::compute::conformance::filter::test_filter_conformance; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn filter_bool_test() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from_iter([true, true, false]); let mask = Mask::from_iter([true, false, true]); @@ -326,7 +330,7 @@ mod tests { #[test] fn filter_bool_sparse_index_mask() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from_iter((0..100).map(|i| i % 2 == 0)); let mask = Mask::from_indices(100, [0, 99]); @@ -336,7 +340,7 @@ mod tests { #[test] fn filter_bool_sparse_slice_mask() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from_iter((0..100).map(|i| i % 2 == 0)); let mask = Mask::from_slices(100, vec![(0, 1), (99, 100)]); @@ -346,7 +350,7 @@ mod tests { #[test] fn filter_bool_sparse_buffer_mask() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from_iter((0..100).map(|i| i % 2 == 0)); let mask = Mask::from_buffer(BitBuffer::from_iter((0..100).map(|i| i == 0 || i == 99))); @@ -371,10 +375,7 @@ mod tests { #[case(BoolArray::from_iter((0..100).map(|i| i % 2 == 0)))] #[case(BoolArray::from_iter((0..1024).map(|i| i % 3 != 0)))] fn test_filter_bool_conformance(#[case] array: BoolArray) { - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[cfg(target_arch = "x86_64")] diff --git a/vortex-array/src/arrays/bool/compute/mask.rs b/vortex-array/src/arrays/bool/compute/mask.rs index 15179804194..818dbaebca5 100644 --- a/vortex-array/src/arrays/bool/compute/mask.rs +++ b/vortex-array/src/arrays/bool/compute/mask.rs @@ -32,6 +32,7 @@ mod tests { use std::any::Any; use std::ops::Range; use std::sync::Arc; + use std::sync::LazyLock; use futures::future::BoxFuture; use rstest::rstest; @@ -39,13 +40,13 @@ mod tests { use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; + use vortex_session::VortexSession; use crate::ArrayEq; use crate::ArrayRef; use crate::EqMode; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Bool; use crate::arrays::BoolArray; use crate::buffer::BufferHandle; @@ -54,6 +55,8 @@ mod tests { use crate::scalar_fn::fns::mask::MaskReduce; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + // Any access beyond buffer metadata would invalidate the metadata-only reduction. #[derive(Debug, PartialEq, Eq, Hash)] struct MetadataOnlyDeviceBuffer(usize); @@ -119,9 +122,6 @@ mod tests { #[case(BoolArray::from_iter([false, false]))] #[case(BoolArray::from_iter((0..100).map(|i| i % 2 == 0)))] fn test_mask_bool_conformance(#[case] array: BoolArray) { - test_mask_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_mask_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/bool/compute/mod.rs b/vortex-array/src/arrays/bool/compute/mod.rs index 6037cac8c36..da5fa766d85 100644 --- a/vortex-array/src/arrays/bool/compute/mod.rs +++ b/vortex-array/src/arrays/bool/compute/mod.rs @@ -13,14 +13,18 @@ mod zip; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::compute::conformance::consistency::test_array_consistency; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] // Basic bool arrays #[case::bool_array(BoolArray::from_iter([true, false, true, true, false]))] @@ -43,9 +47,6 @@ mod tests { None, None, Some(true), None, None, None, Some(false), None, None ]))] fn test_bool_consistency(#[case] array: BoolArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/bool/compute/take.rs b/vortex-array/src/arrays/bool/compute/take.rs index c6b541d3ee9..a19b994bf5c 100644 --- a/vortex-array/src/arrays/bool/compute/take.rs +++ b/vortex-array/src/arrays/bool/compute/take.rs @@ -178,13 +178,15 @@ where #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray as _; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::DictArray; use crate::arrays::PrimitiveArray; @@ -192,9 +194,11 @@ mod test { use crate::compute::conformance::take::test_take_conformance; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn take_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let reference = BoolArray::from_iter(vec![ Some(false), Some(true), @@ -217,7 +221,7 @@ mod test { #[test] fn test_bool_array_take_with_null_out_of_bounds_indices() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = BoolArray::from_iter(vec![Some(false), Some(true), None, None, Some(false)]); let indices = PrimitiveArray::new( buffer![0, 3, 100], @@ -235,7 +239,7 @@ mod test { #[test] fn test_non_null_bool_array_take_with_null_out_of_bounds_indices() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = BoolArray::from_iter(vec![false, true, false, true, false]); let indices = PrimitiveArray::new( buffer![0, 3, 100], @@ -252,7 +256,7 @@ mod test { #[test] fn test_bool_array_take_all_null_indices() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = BoolArray::from_iter(vec![Some(false), Some(true), None, None, Some(false)]); let indices = PrimitiveArray::new( buffer![0, 3, 100], @@ -264,7 +268,7 @@ mod test { #[test] fn test_non_null_bool_array_take_all_null_indices() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = BoolArray::from_iter(vec![false, true, false, true, false]); let indices = PrimitiveArray::new( buffer![0, 3, 100], @@ -280,7 +284,7 @@ mod test { fn test_non_null_constant_bool_take_with_nullable_indices( #[case] value: bool, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = BoolArray::from_iter([value]); let codes = PrimitiveArray::new(buffer![0i64, 0, 0], Validity::AllValid); @@ -300,9 +304,6 @@ mod test { #[case(BoolArray::from_iter([true, false]))] #[case(BoolArray::from_iter([true]))] fn test_take_bool_conformance(#[case] array: BoolArray) { - test_take_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/bool/compute/zip.rs b/vortex-array/src/arrays/bool/compute/zip.rs index 9eaecb2fb39..70e22a27752 100644 --- a/vortex-array/src/arrays/bool/compute/zip.rs +++ b/vortex-array/src/arrays/bool/compute/zip.rs @@ -84,19 +84,23 @@ fn zip_value_bits(if_true: &BitBuffer, if_false: &BitBuffer, mask: &BitBuffer) - #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use super::zip_value_bits; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Bool; use crate::arrays::BoolArray; use crate::assert_arrays_eq; use crate::builtins::ArrayBuiltins; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn blend_value_bits_boundaries() { for len in [0usize, 1, 2, 7, 8, 9, 63, 64, 65, 127, 128] { @@ -133,7 +137,7 @@ mod tests { let bits: Vec = (0..len).map(|i| i.is_multiple_of(5) || i == 64).collect(); let mask = Mask::from_iter(bits.iter().copied()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mask .into_array() .zip(if_true, if_false)? @@ -168,7 +172,7 @@ mod tests { let bits: Vec = (0..len).map(|i| i.is_multiple_of(2)).collect(); let mask = Mask::from_iter(bits.iter().copied()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mask .into_array() .zip(if_true, if_false)? diff --git a/vortex-array/src/arrays/bool/vtable/mod.rs b/vortex-array/src/arrays/bool/vtable/mod.rs index 00b629fa2a6..18fea87307d 100644 --- a/vortex-array/src/arrays/bool/vtable/mod.rs +++ b/vortex-array/src/arrays/bool/vtable/mod.rs @@ -226,22 +226,25 @@ pub struct Bool; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::ByteBufferMut; + use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use crate::ArrayContext; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::assert_arrays_eq; use crate::serde::SerializeOptions; use crate::serde::SerializedArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_nullable_bool_serde_roundtrip() { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = BoolArray::from_iter([Some(true), None, Some(false), None]); let dtype = array.dtype().clone(); let len = array.len(); @@ -250,7 +253,7 @@ mod tests { let serialized = array .clone() .into_array() - .serialize(&array_ctx, &session, &SerializeOptions::default()) + .serialize(&array_ctx, &SESSION, &SerializeOptions::default()) .unwrap(); let mut concat = ByteBufferMut::empty(); @@ -259,7 +262,7 @@ mod tests { } let parts = SerializedArray::try_from(concat.freeze()).unwrap(); let decoded = parts - .decode(&dtype, len, &ReadContext::new(array_ctx.to_ids()), &session) + .decode(&dtype, len, &ReadContext::new(array_ctx.to_ids()), &SESSION) .unwrap(); assert_arrays_eq!(decoded, array, &mut ctx); diff --git a/vortex-array/src/arrays/bool/vtable/operations.rs b/vortex-array/src/arrays/bool/vtable/operations.rs index a7b3d79c1da..46267b96317 100644 --- a/vortex-array/src/arrays/bool/vtable/operations.rs +++ b/vortex-array/src/arrays/bool/vtable/operations.rs @@ -28,17 +28,21 @@ impl OperationsVTable for Bool { #[cfg(test)] mod tests { use std::iter; + use std::sync::LazyLock; + + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::bool::BoolArrayExt; use crate::assert_arrays_eq; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_slice_hundred_elements() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from_iter(iter::repeat_n(Some(true), 100)); let sliced_arr = arr .into_array() @@ -54,7 +58,7 @@ mod tests { #[test] fn test_slice() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = BoolArray::from_iter([Some(true), Some(true), None, Some(false), None]); let sliced_arr = arr.into_array().slice(1..4).unwrap(); diff --git a/vortex-array/src/arrays/chunked/array.rs b/vortex-array/src/arrays/chunked/array.rs index 58bd92ec5bd..6c0169d7a7c 100644 --- a/vortex-array/src/arrays/chunked/array.rs +++ b/vortex-array/src/arrays/chunked/array.rs @@ -296,12 +296,14 @@ impl FromIterator for Array { #[cfg(test)] mod test { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::PrimitiveArray; use crate::arrays::chunked::ChunkedArrayExt; @@ -311,9 +313,11 @@ mod test { use crate::dtype::PType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_rechunk_one_chunk() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let chunked = ChunkedArray::try_new( vec![buffer![0u64].into_array()], DType::Primitive(PType::U64, Nullability::NonNullable), @@ -327,7 +331,7 @@ mod test { #[test] fn test_rechunk_two_chunks() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let chunked = ChunkedArray::try_new( vec![buffer![0u64].into_array(), buffer![5u64].into_array()], DType::Primitive(PType::U64, Nullability::NonNullable), @@ -342,7 +346,7 @@ mod test { #[test] fn test_rechunk_tiny_target_chunks() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let chunked = ChunkedArray::try_new( vec![ buffer![0u64, 1, 2, 3].into_array(), @@ -361,7 +365,7 @@ mod test { #[test] fn test_rechunk_with_too_big_chunk() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let chunked = ChunkedArray::try_new( vec![ buffer![0u64, 1, 2].into_array(), @@ -383,7 +387,7 @@ mod test { #[test] fn test_empty_chunks_all_valid() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create chunks where some are empty but all non-empty chunks have all valid values let chunks = vec![ PrimitiveArray::new(buffer![1u64, 2, 3], Validity::AllValid).into_array(), @@ -404,7 +408,7 @@ mod test { #[test] fn test_empty_chunks_all_invalid() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create chunks where some are empty but all non-empty chunks have all invalid values let chunks = vec![ PrimitiveArray::new(buffer![1u64, 2], Validity::AllInvalid).into_array(), @@ -425,7 +429,7 @@ mod test { #[test] fn test_empty_chunks_mixed_validity() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create chunks with mixed validity including empty chunks let chunks = vec![ PrimitiveArray::new(buffer![1u64, 2], Validity::AllValid).into_array(), diff --git a/vortex-array/src/arrays/chunked/compute/aggregate.rs b/vortex-array/src/arrays/chunked/compute/aggregate.rs index db3eda9f87f..a4c211c0344 100644 --- a/vortex-array/src/arrays/chunked/compute/aggregate.rs +++ b/vortex-array/src/arrays/chunked/compute/aggregate.rs @@ -38,9 +38,12 @@ impl DynAggregateKernel for ChunkedArrayAggregate { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -48,7 +51,6 @@ mod tests { use crate::aggregate_fn::DynAccumulator; use crate::aggregate_fn::NumericalAggregateOpts; use crate::aggregate_fn::fns::sum::Sum; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::PrimitiveArray; @@ -57,8 +59,10 @@ mod tests { use crate::dtype::PType; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn run_sum(batch: &crate::ArrayRef) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut acc = Accumulator::try_new( Sum, NumericalAggregateOpts::default(), diff --git a/vortex-array/src/arrays/chunked/compute/cast.rs b/vortex-array/src/arrays/chunked/compute/cast.rs index 25e312de748..6f52c792f91 100644 --- a/vortex-array/src/arrays/chunked/compute/cast.rs +++ b/vortex-array/src/arrays/chunked/compute/cast.rs @@ -31,12 +31,14 @@ impl CastReduce for Chunked { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -46,9 +48,11 @@ mod test { use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_cast_chunked() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr0 = buffer![0u32, 1].into_array(); let arr1 = buffer![2u32, 3].into_array(); @@ -97,6 +101,6 @@ mod test { DType::Primitive(PType::U8, Nullability::NonNullable) ).unwrap().into_array())] fn test_cast_chunked_conformance(#[case] array: crate::ArrayRef) { - test_cast_conformance(&array, &mut array_session().create_execution_ctx()); + test_cast_conformance(&array, &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/chunked/compute/fill_null.rs b/vortex-array/src/arrays/chunked/compute/fill_null.rs index 71bb932f264..7d05a2914e6 100644 --- a/vortex-array/src/arrays/chunked/compute/fill_null.rs +++ b/vortex-array/src/arrays/chunked/compute/fill_null.rs @@ -33,11 +33,13 @@ impl FillNullReduce for Chunked { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::BitBuffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::assert_arrays_eq; @@ -47,6 +49,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn fill_null_chunks() { let chunked = ChunkedArray::try_new( @@ -64,7 +68,7 @@ mod tests { BoolArray::from_iter([ false, false, false, false, false, true, true, true, true, true ]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } } diff --git a/vortex-array/src/arrays/chunked/compute/filter.rs b/vortex-array/src/arrays/chunked/compute/filter.rs index 0bdaabecc34..083a7f9a547 100644 --- a/vortex-array/src/arrays/chunked/compute/filter.rs +++ b/vortex-array/src/arrays/chunked/compute/filter.rs @@ -201,10 +201,10 @@ pub(crate) fn find_chunk_idx(idx: usize, chunk_ends: &[usize]) -> VortexResult<( mod test { use vortex_buffer::buffer; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -256,12 +256,16 @@ mod test { f16::from_f32(0.22497559), f16::from_f32(3174.0), ]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } + use std::sync::LazyLock; + use rstest::rstest; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(ChunkedArray::try_new( vec![ @@ -292,9 +296,6 @@ mod test { DType::Primitive(PType::I64, Nullability::NonNullable), ).unwrap())] fn test_filter_chunked_conformance(#[case] chunked: ChunkedArray) { - test_filter_conformance( - &chunked.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&chunked.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/chunked/compute/mask.rs b/vortex-array/src/arrays/chunked/compute/mask.rs index f05988de05c..f99d4254780 100644 --- a/vortex-array/src/arrays/chunked/compute/mask.rs +++ b/vortex-array/src/arrays/chunked/compute/mask.rs @@ -39,12 +39,14 @@ impl MaskKernel for Chunked { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::PrimitiveArray; use crate::compute::conformance::mask::test_mask_conformance; @@ -52,6 +54,8 @@ mod test { use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(ChunkedArray::try_new( vec![ @@ -80,9 +84,6 @@ mod test { DType::Primitive(PType::F32, Nullability::NonNullable), ).unwrap())] fn test_mask_chunked_conformance(#[case] chunked: ChunkedArray) { - test_mask_conformance( - &chunked.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_mask_conformance(&chunked.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/chunked/compute/mod.rs b/vortex-array/src/arrays/chunked/compute/mod.rs index 7e75109b1f1..e7c27e00361 100644 --- a/vortex-array/src/arrays/chunked/compute/mod.rs +++ b/vortex-array/src/arrays/chunked/compute/mod.rs @@ -15,12 +15,14 @@ mod zip; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::DecimalArray; use crate::arrays::PrimitiveArray; @@ -31,6 +33,8 @@ mod tests { use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] // Basic chunked arrays #[case::chunked_primitive(ChunkedArray::try_new( @@ -84,10 +88,7 @@ mod tests { ).unwrap())] fn test_chunked_consistency(#[case] array: ChunkedArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[rstest] @@ -169,9 +170,6 @@ mod tests { DType::Decimal(DecimalDType::new(10, 2), Nullability::NonNullable), ).unwrap())] fn test_chunked_binary_numeric(#[case] array: ChunkedArray) { - test_binary_numeric_array( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ) + test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx()) } } diff --git a/vortex-array/src/arrays/chunked/compute/take.rs b/vortex-array/src/arrays/chunked/compute/take.rs index 4785e1a0afa..15511c5a8cc 100644 --- a/vortex-array/src/arrays/chunked/compute/take.rs +++ b/vortex-array/src/arrays/chunked/compute/take.rs @@ -559,16 +559,18 @@ fn contiguous_runs(starts: Vec, lengths: Vec, total: usize) -> ArrayRe #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::Buffer; use vortex_buffer::bitbuffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -586,6 +588,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn chunked_i32() -> VortexResult { ChunkedArray::try_new( vec![ @@ -614,7 +618,7 @@ mod tests { #[test] fn test_take_piecewise_monotonic_spanning_chunks() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; // The second piece crosses the first chunk boundary, the third spans the last two chunks. @@ -631,7 +635,7 @@ mod tests { #[test] fn test_take_piecewise_interleaved() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; // Pieces visit chunks out of order, forcing the reorder take. @@ -648,7 +652,7 @@ mod tests { #[test] fn test_take_piecewise_whole_array() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; let indices = contiguous_pieces(&[0], &[15])?; @@ -660,7 +664,7 @@ mod tests { #[test] fn test_take_piecewise_across_empty_chunk() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = ChunkedArray::try_new( vec![ buffer![0i32, 1, 2, 3, 4].into_array(), @@ -679,7 +683,7 @@ mod tests { #[test] fn test_take_piecewise_adjacent_pieces_merge() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; // The first two pieces are contiguous within one chunk, so they merge into a single run @@ -697,7 +701,7 @@ mod tests { #[test] fn test_take_piecewise_same_chunk_out_of_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; // Non-contiguous pieces in the same chunk must stay separate runs in piece order. @@ -710,7 +714,7 @@ mod tests { #[test] fn test_take_piecewise_zero_length_pieces() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; let indices = contiguous_pieces(&[5, 0, 2], &[0, 4, 0])?; @@ -722,7 +726,7 @@ mod tests { #[test] fn test_take_piecewise_out_of_bounds() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; let indices = contiguous_pieces(&[12], &[5])?; @@ -736,7 +740,7 @@ mod tests { #[test] fn test_take_piecewise_non_unit_multiplier() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; // Multiplier 2 falls back to the generic path but must stay correct. @@ -759,7 +763,7 @@ mod tests { #[test] fn test_take_piecewise_nullable_values() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = ChunkedArray::try_new( vec![ PrimitiveArray::from_option_iter([Some(0i32), None, Some(2)]).into_array(), @@ -781,7 +785,7 @@ mod tests { #[test] fn test_take_fsl_over_chunked_elements() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Chunk boundaries at 8 and 13 do not line up with the list size of 3. let elements = ChunkedArray::try_new( vec![ @@ -822,16 +826,13 @@ mod tests { )? .into_array(); let fsl = FixedSizeListArray::try_new(elements, 3, Validity::NonNullable, 6)?; - test_take_conformance( - &fsl.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&fsl.into_array(), &mut SESSION.create_execution_ctx()); Ok(()) } #[test] fn test_take_chunked_fsl() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let c0 = FixedSizeListArray::try_new( PrimitiveArray::from_iter(0i32..6).into_array(), 2, @@ -862,7 +863,7 @@ mod tests { #[test] fn test_take_chunked_fsl_nullable() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let c0 = FixedSizeListArray::try_new( PrimitiveArray::from_iter(0i32..6).into_array(), 2, @@ -894,7 +895,7 @@ mod tests { #[test] fn test_take_chunked_fsl_non_fsl_chunk() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let c0 = FixedSizeListArray::try_new( PrimitiveArray::from_iter(0i32..6).into_array(), 2, @@ -928,7 +929,7 @@ mod tests { #[test] fn test_take_chunked_fsl_constant_chunk() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let c0 = FixedSizeListArray::try_new( PrimitiveArray::from_iter(0i32..6).into_array(), 2, @@ -955,7 +956,7 @@ mod tests { #[test] fn test_take_piecewise_chunked_fsl() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let c0 = FixedSizeListArray::try_new( PrimitiveArray::from_iter(0i32..6).into_array(), 2, @@ -1005,7 +1006,7 @@ mod tests { #[test] fn test_take_chunked_struct_nested_flatten() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let s0 = StructArray::try_new( ["a"].into(), vec![buffer![0i32, 1, 2].into_array()], @@ -1049,16 +1050,13 @@ mod tests { )?; let dtype = c0.dtype().clone(); let arr = ChunkedArray::try_new(vec![c0.into_array(), c1.into_array()], dtype)?; - test_take_conformance( - &arr.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&arr.into_array(), &mut SESSION.create_execution_ctx()); Ok(()) } #[test] fn test_take() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = buffer![1i32, 2, 3].into_array(); let arr = ChunkedArray::try_new(vec![a.clone(), a.clone(), a.clone()], a.dtype().clone()) .unwrap(); @@ -1072,7 +1070,7 @@ mod tests { #[test] fn test_take_nullable_values() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::AllValid).into_array(); let arr = ChunkedArray::try_new(vec![a.clone(), a.clone(), a.clone()], a.dtype().clone()) .unwrap(); @@ -1090,7 +1088,7 @@ mod tests { #[test] fn test_take_nullable_indices() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = buffer![1i32, 2, 3].into_array(); let arr = ChunkedArray::try_new(vec![a.clone(), a.clone(), a.clone()], a.dtype().clone()) .unwrap(); @@ -1111,7 +1109,7 @@ mod tests { #[test] fn test_take_nullable_struct() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let struct_array = StructArray::try_new(FieldNames::default(), vec![], 100, Validity::NonNullable) .unwrap(); @@ -1137,7 +1135,7 @@ mod tests { #[test] fn test_empty_take() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = buffer![1i32, 2, 3].into_array(); let arr = ChunkedArray::try_new(vec![a.clone(), a.clone(), a.clone()], a.dtype().clone()) .unwrap(); @@ -1158,7 +1156,7 @@ mod tests { #[test] fn test_take_shuffled_indices() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let c0 = buffer![0i32, 1, 2].into_array(); let c1 = buffer![3i32, 4, 5].into_array(); let c2 = buffer![6i32, 7, 8].into_array(); @@ -1183,7 +1181,7 @@ mod tests { #[test] fn test_take_shuffled_duplicates_with_empty_chunks() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let empty = PrimitiveArray::empty::(Nullability::NonNullable).into_array(); let arr = ChunkedArray::try_new( vec![ @@ -1210,7 +1208,7 @@ mod tests { #[test] fn test_take_small_shuffled_fixed_size_lists() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let first = FixedSizeListArray::new( buffer![0i32, 1, 2, 3].into_array(), 2, @@ -1242,7 +1240,7 @@ mod tests { #[test] fn test_take_shuffled_large() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let nchunks: i32 = 100; let chunk_len: i32 = 1_000; let total = nchunks * chunk_len; @@ -1288,7 +1286,7 @@ mod tests { #[test] fn test_take_null_indices() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let c0 = buffer![10i32, 20, 30].into_array(); let c1 = buffer![40i32, 50, 60].into_array(); let arr = ChunkedArray::try_new( @@ -1320,7 +1318,7 @@ mod tests { #[test] fn test_take_sorted_indices() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; // Strictly increasing indices spanning chunks hit the sorted fast path. @@ -1337,7 +1335,7 @@ mod tests { #[test] fn test_take_out_of_bounds() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; // Sorted indices hit the fast path, unsorted the generic path; both must fail. @@ -1352,7 +1350,7 @@ mod tests { #[test] fn test_take_all_null_indices() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = chunked_i32()?; let indices = PrimitiveArray::from_option_iter([None::, None]).into_array(); @@ -1377,20 +1375,14 @@ mod tests { .clone(), ) .unwrap(); - test_take_conformance( - &arr.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&arr.into_array(), &mut SESSION.create_execution_ctx()); // Test with nullable chunked array let a = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]); let b = PrimitiveArray::from_option_iter([Some(4i32), Some(5)]); let dtype = a.dtype().clone(); let arr = ChunkedArray::try_new(vec![a.into_array(), b.into_array()], dtype).unwrap(); - test_take_conformance( - &arr.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&arr.into_array(), &mut SESSION.create_execution_ctx()); // Test with multiple identical chunks let chunk = buffer![10i32, 20, 30, 40, 50].into_array(); @@ -1399,9 +1391,6 @@ mod tests { chunk.dtype().clone(), ) .unwrap(); - test_take_conformance( - &arr.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&arr.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/chunked/compute/zip.rs b/vortex-array/src/arrays/chunked/compute/zip.rs index dc95c194173..dc43043b6c7 100644 --- a/vortex-array/src/arrays/chunked/compute/zip.rs +++ b/vortex-array/src/arrays/chunked/compute/zip.rs @@ -46,13 +46,15 @@ impl ZipKernel for Chunked { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Chunked; use crate::arrays::ChunkedArray; use crate::arrays::PrimitiveArray; @@ -62,9 +64,11 @@ mod tests { use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_chunked_zip_aligns_across_boundaries() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let if_true = ChunkedArray::try_new( vec![ buffer![1i32, 2].into_array(), @@ -94,7 +98,7 @@ mod tests { // One step of execution will push down the zip. let zipped = zipped .clone() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); let zipped = zipped .as_opt::() diff --git a/vortex-array/src/arrays/chunked/paired_chunks.rs b/vortex-array/src/arrays/chunked/paired_chunks.rs index 610c48ecc8e..796daee1b37 100644 --- a/vortex-array/src/arrays/chunked/paired_chunks.rs +++ b/vortex-array/src/arrays/chunked/paired_chunks.rs @@ -117,12 +117,14 @@ impl Iterator for PairedChunks { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::PrimitiveArray; use crate::arrays::chunked::paired_chunks::PairedChunksExt; @@ -130,6 +132,8 @@ mod tests { use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn i32_dtype() -> DType { DType::Primitive(PType::I32, Nullability::NonNullable) } @@ -139,7 +143,7 @@ mod tests { left: &ChunkedArray, right: &ChunkedArray, ) -> VortexResult, Vec, std::ops::Range)>> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut result = Vec::new(); for pair in left.paired_chunks(right) { let pair = pair?; diff --git a/vortex-array/src/arrays/chunked/tests.rs b/vortex-array/src/arrays/chunked/tests.rs index 6168941a70d..c5556b5e1ba 100644 --- a/vortex-array/src/arrays/chunked/tests.rs +++ b/vortex-array/src/arrays/chunked/tests.rs @@ -15,7 +15,6 @@ use crate::ArrayRef; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::Chunked; use crate::arrays::ChunkedArray; use crate::arrays::DictArray; @@ -33,7 +32,7 @@ use crate::dtype::PType::I32; use crate::executor::execute_into_builder; use crate::validity::Validity; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); fn chunked_array() -> ChunkedArray { ChunkedArray::try_new( diff --git a/vortex-array/src/arrays/chunked/vtable/canonical.rs b/vortex-array/src/arrays/chunked/vtable/canonical.rs index d72183ee58b..b0c935fcedb 100644 --- a/vortex-array/src/arrays/chunked/vtable/canonical.rs +++ b/vortex-array/src/arrays/chunked/vtable/canonical.rs @@ -318,7 +318,7 @@ mod tests { use crate::validity::Validity; /// A shared session for these chunked-array tests, used to create execution contexts. - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[derive(Debug)] struct CountingAllocator { @@ -573,7 +573,7 @@ mod tests { fn list_canonicalize_uses_memory_session_allocator() { let allocations = Arc::new(AtomicUsize::new(0)); let session = - crate::array_session().with_allocator(BufferAllocatorRef::new(CountingAllocator { + VortexSession::empty().with_allocator(BufferAllocatorRef::new(CountingAllocator { allocations: Arc::clone(&allocations), })); let mut ctx = session.create_execution_ctx(); diff --git a/vortex-array/src/arrays/chunked/vtable/operations.rs b/vortex-array/src/arrays/chunked/vtable/operations.rs index 13b2379ca73..f228228acf4 100644 --- a/vortex-array/src/arrays/chunked/vtable/operations.rs +++ b/vortex-array/src/arrays/chunked/vtable/operations.rs @@ -41,14 +41,15 @@ impl OperationsVTable for Chunked { #[cfg(test)] mod tests { use std::ops::Range; + use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -57,6 +58,8 @@ mod tests { use crate::dtype::PType; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn chunked_array() -> ChunkedArray { ChunkedArray::try_new( vec![ @@ -77,7 +80,7 @@ mod tests { #[case::end(7..8, &[8u64])] #[case::exactly_end(6..9, &[7u64, 8, 9])] fn slice(#[case] range: Range, #[case] expected: &[u64]) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( chunked_array().slice(range).unwrap(), PrimitiveArray::from_iter(expected.iter().copied()), @@ -93,13 +96,13 @@ mod tests { assert_arrays_eq!( sliced, PrimitiveArray::empty::(Nullability::NonNullable), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } #[test] fn scalar_at_empty_children_both_sides() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = ChunkedArray::try_new( vec![ Buffer::::empty().into_array(), @@ -122,7 +125,7 @@ mod tests { #[test] fn scalar_at_empty_children_trailing() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = ChunkedArray::try_new( vec![ buffer![1u64, 2].into_array(), @@ -144,7 +147,7 @@ mod tests { #[test] fn scalar_at_empty_children_leading() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = ChunkedArray::try_new( vec![ Buffer::::empty().into_array(), diff --git a/vortex-array/src/arrays/constant/compute/cast.rs b/vortex-array/src/arrays/constant/compute/cast.rs index 439bf8367b8..ea26f632bb8 100644 --- a/vortex-array/src/arrays/constant/compute/cast.rs +++ b/vortex-array/src/arrays/constant/compute/cast.rs @@ -22,11 +22,13 @@ impl CastReduce for Constant { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ConstantArray; use crate::builtins::ArrayBuiltins; use crate::compute::conformance::cast::test_cast_conformance; @@ -36,6 +38,8 @@ mod tests { use crate::scalar::DecimalValue; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(ConstantArray::new(Scalar::from(42u32), 5).into_array())] #[case(ConstantArray::new(Scalar::from(-100i32), 10).into_array())] @@ -44,7 +48,7 @@ mod tests { #[case(ConstantArray::new(Scalar::null_native::(), 4).into_array())] #[case(ConstantArray::new(Scalar::from(255u8), 1).into_array())] fn test_cast_constant_conformance(#[case] array: crate::ArrayRef) { - test_cast_conformance(&array, &mut array_session().create_execution_ctx()); + test_cast_conformance(&array, &mut SESSION.create_execution_ctx()); } #[test] @@ -58,7 +62,7 @@ mod tests { assert_eq!(casted.dtype(), &target_dtype); let scalar = casted - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!( scalar.as_decimal().decimal_value(), diff --git a/vortex-array/src/arrays/constant/compute/fill_null.rs b/vortex-array/src/arrays/constant/compute/fill_null.rs index 040caf0a383..a559bbb8a70 100644 --- a/vortex-array/src/arrays/constant/compute/fill_null.rs +++ b/vortex-array/src/arrays/constant/compute/fill_null.rs @@ -21,9 +21,12 @@ impl FillNullReduce for Constant { #[cfg(test)] mod test { + use std::sync::LazyLock; + + use vortex_session::VortexSession; + use crate::IntoArray as _; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ConstantArray; use crate::assert_arrays_eq; use crate::builtins::ArrayBuiltins; @@ -32,9 +35,11 @@ mod test { use crate::dtype::PType; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_null() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = ConstantArray::new(Scalar::null_native::(), 3) .into_array() .fill_null(Scalar::from(1)) @@ -48,7 +53,7 @@ mod test { #[test] fn test_non_null() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = ConstantArray::new(Scalar::from(Some(1)), 3) .into_array() .fill_null(Scalar::from(2)) @@ -62,7 +67,7 @@ mod test { #[test] fn test_non_nullable_with_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = ConstantArray::new(Scalar::from(1), 3) .into_array() .fill_null(Scalar::new( diff --git a/vortex-array/src/arrays/constant/compute/mod.rs b/vortex-array/src/arrays/constant/compute/mod.rs index a996bf79a0f..2a6f0bb0ce5 100644 --- a/vortex-array/src/arrays/constant/compute/mod.rs +++ b/vortex-array/src/arrays/constant/compute/mod.rs @@ -14,12 +14,13 @@ pub(crate) mod uncompressed_size; #[cfg(test)] mod test { use std::f64; + use std::sync::LazyLock; use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ConstantArray; use crate::compute::conformance::consistency::test_array_consistency; use crate::compute::conformance::filter::test_filter_conformance; @@ -27,23 +28,25 @@ mod test { use crate::dtype::half::f16; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_mask_constant() { test_mask_conformance( &ConstantArray::new(Scalar::null_native::(), 5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_mask_conformance( &ConstantArray::new(Scalar::from(3u16), 5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_mask_conformance( &ConstantArray::new(Scalar::from(1.0f32 / 0.0f32), 5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_mask_conformance( &ConstantArray::new(Scalar::from(f16::from_f32(3.0f32)), 5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -51,19 +54,19 @@ mod test { fn test_filter_constant() { test_filter_conformance( &ConstantArray::new(Scalar::null_native::(), 5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( &ConstantArray::new(Scalar::from(3u16), 5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( &ConstantArray::new(Scalar::from(1.0f32 / 0.0f32), 5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( &ConstantArray::new(Scalar::from(f16::from_f32(3.0f32)), 5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -84,9 +87,6 @@ mod test { #[case::constant_single(ConstantArray::new(Scalar::from(99u64), 1))] #[case::constant_large(ConstantArray::new(Scalar::from("hello"), 1000))] fn test_constant_consistency(#[case] array: ConstantArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/constant/compute/take.rs b/vortex-array/src/arrays/constant/compute/take.rs index 7f416d009aa..445f7ef6af6 100644 --- a/vortex-array/src/arrays/constant/compute/take.rs +++ b/vortex-array/src/arrays/constant/compute/take.rs @@ -61,14 +61,15 @@ impl Constant { #[cfg(test)] mod tests { use std::f64; + use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::buffer; use vortex_mask::AllOr; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -77,9 +78,11 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn take_nullable_indices() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = ConstantArray::new(42, 10).into_array(); let taken = array .take( @@ -116,7 +119,7 @@ mod tests { #[test] fn take_all_valid_indices() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = ConstantArray::new(42, 10).into_array(); let taken = array .take(PrimitiveArray::new(buffer![0, 5, 7], Validity::AllValid).into_array()) @@ -148,9 +151,6 @@ mod tests { #[case(ConstantArray::new(Scalar::null_native::(), 5))] #[case(ConstantArray::new(true, 1))] fn test_take_constant_conformance(#[case] array: ConstantArray) { - test_take_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/constant/compute/uncompressed_size.rs b/vortex-array/src/arrays/constant/compute/uncompressed_size.rs index 07e88da2111..380adde03ab 100644 --- a/vortex-array/src/arrays/constant/compute/uncompressed_size.rs +++ b/vortex-array/src/arrays/constant/compute/uncompressed_size.rs @@ -3,9 +3,12 @@ #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::Buffer; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::Canonical; @@ -16,7 +19,6 @@ mod tests { use crate::aggregate_fn::fns::uncompressed_size_in_bytes::UncompressedSizeInBytes; use crate::aggregate_fn::fns::uncompressed_size_in_bytes::UncompressedSizeOpts; use crate::aggregate_fn::fns::uncompressed_size_in_bytes::canonical_uncompressed_size_in_bytes; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; @@ -26,12 +28,14 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn aggregate(array: &ArrayRef) -> VortexResult { aggregate_with(array, UncompressedSizeOpts::default()) } fn aggregate_with(array: &ArrayRef, opts: UncompressedSizeOpts) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut acc = Accumulator::try_new(UncompressedSizeInBytes, opts, array.dtype().clone())?; acc.accumulate(array, &mut ctx)?; acc.finish()? @@ -89,7 +93,7 @@ mod tests { #[test] fn constant_utf8_matches_canonical_size() -> VortexResult<()> { let constant = ConstantArray::new("abcdefghijkl".to_string(), 10).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let canonical = constant.clone().execute::(&mut ctx)?; let expected = canonical_uncompressed_size_in_bytes( &canonical, diff --git a/vortex-array/src/arrays/constant/vtable/canonical.rs b/vortex-array/src/arrays/constant/vtable/canonical.rs index 8ad98aacd86..bbea85c4077 100644 --- a/vortex-array/src/arrays/constant/vtable/canonical.rs +++ b/vortex-array/src/arrays/constant/vtable/canonical.rs @@ -552,7 +552,7 @@ mod tests { use crate::validity::Validity; /// A shared session for these constant-array tests, used to create execution contexts. - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_canonicalize_null() { diff --git a/vortex-array/src/arrays/constant/vtable/mod.rs b/vortex-array/src/arrays/constant/vtable/mod.rs index 3719a91ca71..3b55071ffb8 100644 --- a/vortex-array/src/arrays/constant/vtable/mod.rs +++ b/vortex-array/src/arrays/constant/vtable/mod.rs @@ -414,9 +414,11 @@ fn append_value_or_nulls( #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use rstest::rstest; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::ExecutionCtx; @@ -447,6 +449,8 @@ mod tests { use crate::extension::datetime::TimeUnit; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn assert_constant_values( array: &ArrayRef, scalar: &Scalar, @@ -463,7 +467,7 @@ mod tests { /// Checks append against both the fixture scalar and the canonicalization path. fn assert_append_matches_canonical(array: ConstantArray) -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scalar = array.scalar().clone(); let len = array.len(); @@ -601,7 +605,7 @@ mod tests { /// across the whole run. #[test] fn test_list_constant_append_keeps_one_copy_of_the_elements() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scalar = Scalar::list( Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)), vec![Scalar::from(1i32), Scalar::from(2i32), Scalar::from(3i32)], @@ -632,7 +636,7 @@ mod tests { /// share its elements there and takes the canonical path instead. #[test] fn test_list_constant_append_into_list_builder() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let element_dtype: Arc = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let scalar = Scalar::list( @@ -688,7 +692,7 @@ mod tests { /// a value per row per field. #[test] fn test_struct_constant_append_keeps_fields_constant() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fields = StructFields::new( ["x", "y"].into(), vec![ @@ -752,7 +756,7 @@ mod tests { /// tile's chunks stay constant-encoded rather than materializing a value per row. #[test] fn test_uniform_fixed_size_list_constant_append_keeps_elements_constant() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scalar = Scalar::fixed_size_list( Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)), vec![Scalar::from(7i32), Scalar::from(7i32)], @@ -792,7 +796,7 @@ mod tests { /// the storage constant-encoded. #[test] fn test_extension_constant_append_keeps_storage_constant() -> VortexResult<()> { - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scalar = Scalar::extension::(TimeUnit::Days, Scalar::from(Some(42i32))); let array = ConstantArray::new(scalar.clone(), 1_000); diff --git a/vortex-array/src/arrays/constant/vtable/operations.rs b/vortex-array/src/arrays/constant/vtable/operations.rs index 1993d43e344..a26187d080b 100644 --- a/vortex-array/src/arrays/constant/vtable/operations.rs +++ b/vortex-array/src/arrays/constant/vtable/operations.rs @@ -23,7 +23,10 @@ impl OperationsVTable for Constant { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -34,6 +37,8 @@ mod tests { use crate::dtype::UnionVariants; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn scalar_at_preserves_union_scalar() -> VortexResult<()> { let variants = UnionVariants::try_new( @@ -52,7 +57,7 @@ mod tests { Nullability::Nullable, )?; let array = ConstantArray::new(scalar.clone(), 3).into_array(); - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = array.execute_scalar(1, &mut ctx)?; assert_eq!(actual.dtype(), scalar.dtype()); diff --git a/vortex-array/src/arrays/datetime/test.rs b/vortex-array/src/arrays/datetime/test.rs index b84bfa372a0..2e641e262d4 100644 --- a/vortex-array/src/arrays/datetime/test.rs +++ b/vortex-array/src/arrays/datetime/test.rs @@ -1,15 +1,17 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::EqMode; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::PrimitiveArray; use crate::arrays::datetime::TemporalData; @@ -25,9 +27,11 @@ use crate::hash::ArrayEq; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + macro_rules! test_temporal_roundtrip { ($prim:ty, $constructor:expr, $unit:expr) => {{ - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = buffer![100 as $prim].into_array(); let temporal: TemporalData = $constructor(array, $unit); @@ -148,7 +152,7 @@ test_fail_case!( // We test Timestamp explicitly to avoid the macro getting too complex. #[test] fn test_timestamp() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ts = buffer![100i64].into_array(); let ts_array = ts.into_array(); @@ -204,7 +208,7 @@ fn test_validity_preservation(#[case] validity: Validity) { let prim = temporal_array .temporal_values() .clone() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert!( prim.validity() @@ -233,7 +237,7 @@ fn comparison_rejects_mismatched_timestamp_units() -> VortexResult<()> { let error = temporal .into_array() .apply(&filter_expr)? - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap_err(); assert!( error diff --git a/vortex-array/src/arrays/decimal/compute/cast.rs b/vortex-array/src/arrays/decimal/compute/cast.rs index 3be6332cc41..29b38ce9406 100644 --- a/vortex-array/src/arrays/decimal/compute/cast.rs +++ b/vortex-array/src/arrays/decimal/compute/cast.rs @@ -490,15 +490,17 @@ fn upcast_decimal_buffer(from: Buffe #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::upcast_decimal_values; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::DecimalArray; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -516,6 +518,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::workflow(0, vec![0, 1], vec![0, 1])] #[case::fractional(1, vec![-199, -1, 0, 1, 199], vec![-19, 0, 0, 0, 19])] @@ -532,7 +536,7 @@ mod tests { #[case] values: Vec, #[case] expected: Vec, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(76, scale); let array = DecimalArray::new( values.iter().copied().map(i256::from_i128).collect(), @@ -561,7 +565,7 @@ mod tests { #[case::negative_scale(-5)] #[case::extreme_negative_scale(-128)] fn cast_decimal_to_f64_matches_scalar_cast(#[case] scale: i8) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(76, scale); let beyond_i128 = i256::from_i128(i128::MAX) + i256::ONE; let values = vec![ @@ -620,7 +624,7 @@ mod tests { )] target: PType, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(3, 1); let array = match_each_decimal_value_type!(storage, |F| { DecimalArray::from_option_iter( @@ -655,7 +659,7 @@ mod tests { )] target: PType, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(76, 1); let dtype = DType::Primitive(target, Nullability::NonNullable); match_each_integer_ptype!(target, |T| { @@ -707,7 +711,7 @@ mod tests { #[test] fn cast_decimal_to_integer_masks_and_empty() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(21, 0); let target = DType::Primitive(PType::I8, Nullability::Nullable); for validity in [Validity::from_iter([false, true]), Validity::AllInvalid] { @@ -736,7 +740,7 @@ mod tests { #[test] fn cast_decimal_to_integer_wide_storage() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let factor = i256::from_i128(10).checked_pow(40).unwrap(); let value = i256::from_i128(123) * factor + i256::ONE; let decimal_dtype = DecimalDType::new(76, 40); @@ -764,7 +768,7 @@ mod tests { #[test] fn cast_decimal_to_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(10, 2); let array = DecimalArray::new( buffer![100i32, 200, 300], @@ -793,7 +797,7 @@ mod tests { #[test] fn cast_nullable_to_non_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(10, 2); // Create nullable array with no nulls @@ -824,7 +828,7 @@ mod tests { #[test] #[should_panic(expected = "Cannot cast array with invalid values to non-nullable type")] fn cast_nullable_with_nulls_to_non_nullable_fails() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(10, 2); // Create nullable array with nulls @@ -841,7 +845,7 @@ mod tests { #[test] fn cast_different_scale_rescales() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = DecimalArray::new( buffer![100i32], DecimalDType::new(10, 2), @@ -865,7 +869,7 @@ mod tests { #[test] fn cast_downcast_precision_succeeds_when_values_fit() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = DecimalArray::new( buffer![100i64], DecimalDType::new(18, 2), @@ -888,7 +892,7 @@ mod tests { #[test] fn cast_downcast_precision_checks_values() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = DecimalArray::new( buffer![1000i64], DecimalDType::new(18, 0), @@ -912,7 +916,7 @@ mod tests { #[test] fn cast_lower_scale_requires_exact_rescale() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = DecimalArray::new( buffer![123456i64], DecimalDType::new(10, 4), @@ -936,7 +940,7 @@ mod tests { #[test] fn cast_lower_scale_ignores_null_lane_failures() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = DecimalArray::new( buffer![100i64, 123456], DecimalDType::new(10, 4), @@ -955,10 +959,7 @@ mod tests { .as_ref() .validity() .unwrap() - .execute_mask( - casted.as_ref().len(), - &mut array_session().create_execution_ctx(), - ) + .execute_mask(casted.as_ref().len(), &mut SESSION.create_execution_ctx()) .unwrap(); assert!(mask.value(0)); assert!(!mask.value(1)); @@ -967,7 +968,7 @@ mod tests { #[test] fn cast_upcast_precision_succeeds() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = DecimalArray::new( buffer![100i32, 200, 300], DecimalDType::new(10, 2), @@ -997,7 +998,7 @@ mod tests { #[test] fn cast_widening_same_physical_type_is_zero_copy() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Decimal(10,2) and Decimal(18,2) are both physically i64 with the same scale, so widening // the precision must reuse the values buffer rather than allocate and re-scan it. let array = DecimalArray::new( @@ -1029,7 +1030,7 @@ mod tests { #[test] fn cast_to_non_decimal_returns_err() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = DecimalArray::new( buffer![100i32], DecimalDType::new(10, 2), @@ -1057,10 +1058,7 @@ mod tests { #[case(DecimalArray::from_option_iter([Some(100i32), None, Some(300)], DecimalDType::new(10, 2)))] #[case(DecimalArray::new(buffer![42i32], DecimalDType::new(5, 1), Validity::NonNullable))] fn test_cast_decimal_conformance(#[case] array: DecimalArray) { - test_cast_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_cast_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[test] @@ -1122,7 +1120,7 @@ mod tests { assert_arrays_eq!( casted, DecimalArray::from_iter([100i32, 200, 300], decimal_dtype), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1142,10 +1140,7 @@ mod tests { .as_ref() .validity() .unwrap() - .execute_mask( - casted.as_ref().len(), - &mut array_session().create_execution_ctx(), - ) + .execute_mask(casted.as_ref().len(), &mut SESSION.create_execution_ctx()) .unwrap(); assert!(mask.value(0)); assert!(!mask.value(1)); @@ -1186,7 +1181,7 @@ mod tests { let casted = array.into_array().cast(target.clone()).unwrap(); assert_eq!(casted.dtype(), &target); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let primitive = casted .execute::(&mut ctx) .unwrap() @@ -1202,7 +1197,7 @@ mod tests { let casted = array.into_array().cast(target.clone()).unwrap(); assert_eq!(casted.dtype(), &target); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let primitive = casted .execute::(&mut ctx) .unwrap() @@ -1231,7 +1226,7 @@ mod tests { let casted = array.into_array().cast(target.clone()).unwrap(); assert_eq!(casted.dtype(), &target); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( casted, PrimitiveArray::from_option_iter([None::; 3]), diff --git a/vortex-array/src/arrays/decimal/compute/fill_null.rs b/vortex-array/src/arrays/decimal/compute/fill_null.rs index 5cd024205a7..3755f6c6d1f 100644 --- a/vortex-array/src/arrays/decimal/compute/fill_null.rs +++ b/vortex-array/src/arrays/decimal/compute/fill_null.rs @@ -86,12 +86,14 @@ fn fill_buffer( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::DecimalArray; use crate::assert_arrays_eq; use crate::builtins::ArrayBuiltins; @@ -102,9 +104,11 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn fill_null_leading_none() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(19, 2); let arr = DecimalArray::from_option_iter( [None, Some(800i128), None, Some(1000i128), None], @@ -133,10 +137,7 @@ mod tests { p.as_ref() .validity() .unwrap() - .execute_mask( - p.as_ref().len(), - &mut array_session().create_execution_ctx() - ) + .execute_mask(p.as_ref().len(), &mut SESSION.create_execution_ctx()) .unwrap() .all_true() ); @@ -144,7 +145,7 @@ mod tests { #[test] fn fill_null_all_none() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(19, 2); let arr = DecimalArray::from_option_iter( @@ -172,7 +173,7 @@ mod tests { #[case(DecimalValue::I16(200), DecimalType::I16)] #[case(DecimalValue::I128(200), DecimalType::I128)] fn fill_null_overflow_upcasts(#[case] fill: DecimalValue, #[case] expected_type: DecimalType) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(3, 0); let arr = DecimalArray::from_option_iter([None, Some(10i8), None], decimal_dtype); // i8 max is 127, so 200 requires widening to the fill value's storage type. @@ -196,7 +197,7 @@ mod tests { #[test] fn fill_null_non_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(19, 2); let arr = DecimalArray::new( diff --git a/vortex-array/src/arrays/decimal/compute/mod.rs b/vortex-array/src/arrays/decimal/compute/mod.rs index a6e1cfb2848..88a8713c2dd 100644 --- a/vortex-array/src/arrays/decimal/compute/mod.rs +++ b/vortex-array/src/arrays/decimal/compute/mod.rs @@ -10,12 +10,14 @@ pub mod rules; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::DecimalArray; use crate::compute::conformance::binary_numeric::test_binary_numeric_array; use crate::compute::conformance::consistency::test_array_consistency; @@ -23,6 +25,8 @@ mod tests { use crate::dtype::NativeDecimalType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] // From test_all_consistency #[case::decimal_array(DecimalArray::new( @@ -57,10 +61,7 @@ mod tests { Validity::NonNullable, ))] fn test_decimal_consistency(#[case] array: DecimalArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[rstest] @@ -113,9 +114,6 @@ mod tests { Validity::NonNullable, ))] fn test_decimal_binary_numeric(#[case] array: DecimalArray) { - test_binary_numeric_array( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/decimal/compute/rules.rs b/vortex-array/src/arrays/decimal/compute/rules.rs index a6775aba54a..8f1d09ea92a 100644 --- a/vortex-array/src/arrays/decimal/compute/rules.rs +++ b/vortex-array/src/arrays/decimal/compute/rules.rs @@ -88,6 +88,7 @@ mod tests { use std::any::Any; use std::ops::Range; use std::sync::Arc; + use std::sync::LazyLock; use futures::future::BoxFuture; use num_traits::AsPrimitive; @@ -98,10 +99,10 @@ mod tests { use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_err; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Decimal; use crate::arrays::DecimalArray; use crate::assert_arrays_eq; @@ -112,6 +113,8 @@ mod tests { use crate::match_each_decimal_value_type; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + // Host-backed storage exposes device slicing without allowing implicit host copies. #[derive(Debug, PartialEq, Eq, Hash)] struct TestDeviceBuffer(ByteBuffer); @@ -163,7 +166,7 @@ mod tests { )] values_type: DecimalType, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bytes = match_each_decimal_value_type!(values_type, |D| { Buffer::::from_iter([-12i8, 34, -56, 78, 90, 12].map(|value| value.as_())) .into_byte_buffer() diff --git a/vortex-array/src/arrays/decimal/vtable/mod.rs b/vortex-array/src/arrays/decimal/vtable/mod.rs index c103e35cafd..fe4d8ddeea7 100644 --- a/vortex-array/src/arrays/decimal/vtable/mod.rs +++ b/vortex-array/src/arrays/decimal/vtable/mod.rs @@ -218,14 +218,16 @@ pub struct Decimal; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::ByteBufferMut; use vortex_buffer::buffer; + use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use crate::ArrayContext; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Decimal; use crate::arrays::DecimalArray; use crate::assert_arrays_eq; @@ -234,9 +236,10 @@ mod tests { use crate::serde::SerializedArray; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_array_serde() { - let session = array_session(); let array = DecimalArray::new( buffer![100i128, 200i128, 300i128, 400i128, 500i128], DecimalDType::new(10, 2), @@ -247,7 +250,7 @@ mod tests { let array_ctx = ArrayContext::empty(); let out = array .into_array() - .serialize(&array_ctx, &session, &SerializeOptions::default()) + .serialize(&array_ctx, &SESSION, &SerializeOptions::default()) .unwrap(); // Concat into a single buffer let mut concat = ByteBufferMut::empty(); @@ -259,20 +262,19 @@ mod tests { let parts = SerializedArray::try_from(concat).unwrap(); let decoded = parts - .decode(&dtype, 5, &ReadContext::new(array_ctx.to_ids()), &session) + .decode(&dtype, 5, &ReadContext::new(array_ctx.to_ids()), &SESSION) .unwrap(); assert!(decoded.is::()); assert_arrays_eq!( decoded, DecimalArray::from_iter([100i128, 200, 300, 400, 500], DecimalDType::new(10, 2)), - &mut session.create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } #[test] fn test_nullable_decimal_serde_roundtrip() { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = DecimalArray::new( buffer![1234567i32, 0i32, -9999999i32], DecimalDType::new(7, 3), @@ -285,7 +287,7 @@ mod tests { let out = array .clone() .into_array() - .serialize(&array_ctx, &session, &SerializeOptions::default()) + .serialize(&array_ctx, &SESSION, &SerializeOptions::default()) .unwrap(); let mut concat = ByteBufferMut::empty(); for buf in out { @@ -294,7 +296,7 @@ mod tests { let parts = SerializedArray::try_from(concat.freeze()).unwrap(); let decoded = parts - .decode(&dtype, len, &ReadContext::new(array_ctx.to_ids()), &session) + .decode(&dtype, len, &ReadContext::new(array_ctx.to_ids()), &SESSION) .unwrap(); assert_arrays_eq!(decoded, array, &mut ctx); diff --git a/vortex-array/src/arrays/decimal/vtable/operations.rs b/vortex-array/src/arrays/decimal/vtable/operations.rs index 65824bf5d10..09d1d31a29c 100644 --- a/vortex-array/src/arrays/decimal/vtable/operations.rs +++ b/vortex-array/src/arrays/decimal/vtable/operations.rs @@ -31,11 +31,13 @@ impl OperationsVTable for Decimal { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Decimal; use crate::arrays::DecimalArray; use crate::assert_arrays_eq; @@ -45,6 +47,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_slice() { let array = DecimalArray::new( @@ -75,7 +79,7 @@ mod tests { assert_arrays_eq!( sliced, DecimalArray::from_option_iter([Some(200i128), None], DecimalDType::new(3, 2)), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -89,7 +93,7 @@ mod tests { assert_eq!( array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::decimal( DecimalValue::I128(100), diff --git a/vortex-array/src/arrays/dict/array.rs b/vortex-array/src/arrays/dict/array.rs index 3efd20c4382..79f5ac8be33 100644 --- a/vortex-array/src/arrays/dict/array.rs +++ b/vortex-array/src/arrays/dict/array.rs @@ -356,6 +356,8 @@ impl Array { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rand::RngExt; use rand::SeedableRng; use rand::distr::Distribution; @@ -367,11 +369,11 @@ mod test { use vortex_error::VortexResult; use vortex_error::vortex_panic; use vortex_mask::AllOr; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::DictArray; use crate::arrays::PrimitiveArray; @@ -387,6 +389,8 @@ mod test { use crate::dtype::UnsignedPType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn nullable_codes_validity() { let dict = DictArray::try_new( @@ -402,10 +406,7 @@ mod test { .as_ref() .validity() .unwrap() - .execute_mask( - dict.as_ref().len(), - &mut array_session().create_execution_ctx(), - ) + .execute_mask(dict.as_ref().len(), &mut SESSION.create_execution_ctx()) .unwrap(); let AllOr::Some(indices) = mask.indices() else { vortex_panic!("Expected indices from mask") @@ -428,10 +429,7 @@ mod test { .as_ref() .validity() .unwrap() - .execute_mask( - dict.as_ref().len(), - &mut array_session().create_execution_ctx(), - ) + .execute_mask(dict.as_ref().len(), &mut SESSION.create_execution_ctx()) .unwrap(); let AllOr::Some(indices) = mask.indices() else { vortex_panic!("Expected indices from mask") @@ -458,10 +456,7 @@ mod test { .as_ref() .validity() .unwrap() - .execute_mask( - dict.as_ref().len(), - &mut array_session().create_execution_ctx(), - ) + .execute_mask(dict.as_ref().len(), &mut SESSION.create_execution_ctx()) .unwrap(); let AllOr::Some(indices) = mask.indices() else { vortex_panic!("Expected indices from mask") @@ -484,10 +479,7 @@ mod test { .as_ref() .validity() .unwrap() - .execute_mask( - dict.as_ref().len(), - &mut array_session().create_execution_ctx(), - ) + .execute_mask(dict.as_ref().len(), &mut SESSION.create_execution_ctx()) .unwrap(); let AllOr::Some(indices) = mask.indices() else { vortex_panic!("Expected indices from mask") @@ -534,7 +526,7 @@ mod test { let values = VarBinViewArray::from_iter_str(["zero", "one", "two"]); let dict = DictArray::try_new(buffer![2u8, 0, 2, 1].into_array(), values.into_array())?; let expected = VarBinViewArray::from_iter_str(["two", "zero", "two", "one"]); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinBuilder::::with_capacity_in( dict.dtype().clone(), dict.len(), @@ -550,7 +542,7 @@ mod test { #[test] fn test_dict_array_from_primitive_chunks() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let len = 2; let chunk_count = 2; let (array, expected) = make_dict_primitive_chunks::(len, 2, chunk_count); @@ -560,10 +552,7 @@ mod test { len * chunk_count, ctx.allocator(), ); - array.append_to_builder( - builder.as_mut(), - &mut array_session().create_execution_ctx(), - )?; + array.append_to_builder(builder.as_mut(), &mut SESSION.create_execution_ctx())?; let prim_into = builder.finish_into_canonical(&mut ctx).into_primitive(); @@ -631,7 +620,7 @@ mod test { }; let dict = DictArray::try_new(codes, PrimitiveArray::from_iter(0..num_values).into_array())?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mask = dict.compute_referenced_values_mask(referenced, &mut ctx)?; assert_eq!(mask, BitBuffer::from(expected)); diff --git a/vortex-array/src/arrays/dict/compute/cast.rs b/vortex-array/src/arrays/dict/compute/cast.rs index b9d047511d3..2c705464d53 100644 --- a/vortex-array/src/arrays/dict/compute/cast.rs +++ b/vortex-array/src/arrays/dict/compute/cast.rs @@ -69,7 +69,7 @@ mod tests { use crate::dtype::PType; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_cast_dict_to_wider_type() { diff --git a/vortex-array/src/arrays/dict/compute/fill_null.rs b/vortex-array/src/arrays/dict/compute/fill_null.rs index efe60c030e3..077ee865bda 100644 --- a/vortex-array/src/arrays/dict/compute/fill_null.rs +++ b/vortex-array/src/arrays/dict/compute/fill_null.rs @@ -89,13 +89,15 @@ impl FillNullKernel for Dict { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::BitBuffer; use vortex_buffer::buffer; use vortex_error::VortexExpect; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::DictArray; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -104,9 +106,11 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn nullable_codes_fill_in_values() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict = DictArray::try_new( PrimitiveArray::new( buffer![0u32, 1, 2], diff --git a/vortex-array/src/arrays/dict/compute/filter.rs b/vortex-array/src/arrays/dict/compute/filter.rs index e2601702e8f..46387684a5c 100644 --- a/vortex-array/src/arrays/dict/compute/filter.rs +++ b/vortex-array/src/arrays/dict/compute/filter.rs @@ -38,13 +38,15 @@ impl FilterReduce for Dict { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ConstantArray; use crate::arrays::Dict; use crate::arrays::DictArray; @@ -56,9 +58,11 @@ mod tests { use crate::expr::stats::StatsProviderExt; use crate::scalar::ScalarValue; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn filter_constant_valid_code_keeps_only_referenced_value() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict = DictArray::new( ConstantArray::new(1u8, 5).into_array(), buffer![10i32, 20, 30].into_array(), diff --git a/vortex-array/src/arrays/dict/compute/like.rs b/vortex-array/src/arrays/dict/compute/like.rs index da51e1cc0b3..ba4bf2f9f8c 100644 --- a/vortex-array/src/arrays/dict/compute/like.rs +++ b/vortex-array/src/arrays/dict/compute/like.rs @@ -51,12 +51,14 @@ impl LikeReduce for Dict { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::DictArray; use crate::arrays::VarBinArray; @@ -66,9 +68,11 @@ mod tests { use crate::scalar_fn::fns::like::Like; use crate::scalar_fn::fns::like::LikeOptions; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn like_reduce_dict() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict = DictArray::try_new( buffer![0u8, 1, 0, 2].into_array(), VarBinArray::from(vec!["hello", "world", "help"]).into_array(), diff --git a/vortex-array/src/arrays/dict/compute/min_max.rs b/vortex-array/src/arrays/dict/compute/min_max.rs index 0122761c7bf..e8dab67b052 100644 --- a/vortex-array/src/arrays/dict/compute/min_max.rs +++ b/vortex-array/src/arrays/dict/compute/min_max.rs @@ -76,7 +76,7 @@ mod tests { use crate::arrays::PrimitiveArray; use crate::builders::dict::dict_encode; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); fn assert_min_max(array: &ArrayRef, expected: Option<(i32, i32)>) -> VortexResult<()> { let mut ctx = SESSION.create_execution_ctx(); diff --git a/vortex-array/src/arrays/dict/compute/mod.rs b/vortex-array/src/arrays/dict/compute/mod.rs index 847d682efd4..25eb0c5e442 100644 --- a/vortex-array/src/arrays/dict/compute/mod.rs +++ b/vortex-array/src/arrays/dict/compute/mod.rs @@ -67,7 +67,7 @@ mod test { use crate::dtype::PType::I32; use crate::scalar_fn::fns::operators::Operator; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn canonicalise_nullable_primitive() { @@ -328,7 +328,7 @@ mod tests { use crate::dtype::DType; use crate::dtype::Nullability; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[rstest] // Primitive arrays diff --git a/vortex-array/src/arrays/dict/compute/rules.rs b/vortex-array/src/arrays/dict/compute/rules.rs index 0eb8eea5930..273d2b8562d 100644 --- a/vortex-array/src/arrays/dict/compute/rules.rs +++ b/vortex-array/src/arrays/dict/compute/rules.rs @@ -265,12 +265,14 @@ impl ArrayParentReduceRule for DictionaryScalarFnCodesPullUpRule { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::Chunked; use crate::arrays::ChunkedArray; @@ -290,6 +292,8 @@ mod tests { use crate::scalar_fn::fns::not::Not; use crate::scalar_fn::fns::operators::Operator; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] #[allow(clippy::disallowed_methods)] fn chunked_dict_with_shared_values_pulls_values_up() -> VortexResult<()> { @@ -306,7 +310,7 @@ mod tests { assert!(ArrayRef::ptr_eq(dict.values(), &values)); assert_eq!(codes.nchunks(), 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( optimized, PrimitiveArray::from_iter([10u32, 20, 30, 10, 20]), @@ -330,7 +334,7 @@ mod tests { let optimized = array.optimize()?; assert!(optimized.is::()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( optimized, PrimitiveArray::from_iter([10u32, 20, 30, 10, 20]), @@ -358,7 +362,7 @@ mod tests { assert_arrays_eq!( result.array(), BoolArray::from_iter([false, true, false, true]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) @@ -373,7 +377,7 @@ mod tests { ConstantArray::new(Scalar::bool(false, Nullability::NonNullable), 3).into_array(); let expr = Binary::try_new(dict, const_false, Operator::And)?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Kleene AND: null AND false == false let expected = BoolArray::from_iter([false, false, false]).into_array(); let optimized = expr.optimize()?; @@ -390,7 +394,7 @@ mod tests { ConstantArray::new(Scalar::bool(true, Nullability::NonNullable), 3).into_array(); let expr = Binary::try_new(dict, const_true, Operator::Or)?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Kleene OR: null OR true == true let expected = BoolArray::from_iter([true, true, true]).into_array(); let optimized = expr.optimize()?; diff --git a/vortex-array/src/arrays/dict/compute/slice.rs b/vortex-array/src/arrays/dict/compute/slice.rs index ac318454021..8477c072cce 100644 --- a/vortex-array/src/arrays/dict/compute/slice.rs +++ b/vortex-array/src/arrays/dict/compute/slice.rs @@ -89,12 +89,14 @@ pub(super) fn slice_constant_code( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::DictArray; use crate::arrays::PrimitiveArray; use crate::arrays::dict::compute::slice::ConstantArray; @@ -104,9 +106,11 @@ mod tests { use crate::dtype::PType; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn slice_constant_valid_code() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict = DictArray::new( ConstantArray::new(1u8, 5).into_array(), buffer![10i32, 20, 30].into_array(), @@ -119,7 +123,7 @@ mod tests { #[test] fn slice_constant_null_code() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict = DictArray::new( ConstantArray::new(Scalar::null(DType::Primitive(PType::U8, Nullable)), 5).into_array(), buffer![10i32, 20, 30].into_array(), diff --git a/vortex-array/src/arrays/dict/tests.rs b/vortex-array/src/arrays/dict/tests.rs index db3f08a5e35..0f648fbc674 100644 --- a/vortex-array/src/arrays/dict/tests.rs +++ b/vortex-array/src/arrays/dict/tests.rs @@ -1,13 +1,15 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use super::DictArray; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::FixedSizeListArray; @@ -22,9 +24,11 @@ use crate::dtype::PType; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_scalar_at_null_code() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict = DictArray::try_new( PrimitiveArray::from_option_iter(vec![None, Some(0u32), None]).into_array(), buffer![1i32].into_array(), @@ -37,7 +41,7 @@ fn test_scalar_at_null_code() { #[test] fn test_canonicalize_dict_with_all_null_array_validity_codes() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let codes = PrimitiveArray::new( buffer![0u32, 1], Validity::Array(BoolArray::from_iter([false, false]).into_array()), @@ -78,7 +82,7 @@ fn test_canonicalize_dict_with_all_null_array_validity_codes() -> VortexResult<( #[test] fn test_dict_display() { - let ctx = array_session().create_execution_ctx(); + let ctx = SESSION.create_execution_ctx(); let x = DictArray::try_new( buffer![0u8, 0, 0, 1, 0, 3].into_array(), VarBinArray::from(vec!["Hello", "你好", "Bonjour", "Hola"]).into_array(), @@ -94,7 +98,7 @@ fn test_dict_display() { #[test] fn test_dict_list_dict_display() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = DictArray::try_new( buffer![0u8, 0, 0, 1, 0, 3, 3, 2].into_array(), >::from_iter([ @@ -142,7 +146,7 @@ fn test_dict_list_dict_display() { #[test] fn canonicalize_constant_nullable_code_over_non_nullable_values() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let code = Scalar::primitive(1u8, Nullability::Nullable); let dict = DictArray::try_new( ConstantArray::new(code, 3).into_array(), @@ -162,7 +166,7 @@ fn canonicalize_constant_nullable_code_over_non_nullable_values() -> VortexResul #[test] fn canonicalize_constant_null_code() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict = DictArray::try_new( ConstantArray::new( Scalar::null(DType::Primitive(PType::U8, Nullability::Nullable)), diff --git a/vortex-array/src/arrays/dict/vtable/mod.rs b/vortex-array/src/arrays/dict/vtable/mod.rs index d566bbeb3a8..a2ba1487a59 100644 --- a/vortex-array/src/arrays/dict/vtable/mod.rs +++ b/vortex-array/src/arrays/dict/vtable/mod.rs @@ -352,20 +352,25 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + + use vortex_session::VortexSession; + use super::*; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::VarBinViewArray; use crate::arrays::dict::DictArray; use crate::assert_arrays_eq; use crate::dtype::Nullability::Nullable; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + const LONG: &str = "a string that is far too long to be inlined in a view"; #[test] fn append_to_builder_gathers_through_the_dictionary() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict = DictArray::try_new( PrimitiveArray::from_option_iter([Some(0u32), Some(2), None, Some(1), Some(0)]) .into_array(), @@ -389,7 +394,7 @@ mod tests { /// null and rows whose dictionary value is null. #[test] fn append_to_view_builder_gathers_through_the_dictionary() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict = DictArray::try_new( PrimitiveArray::from_option_iter([Some(0u32), Some(2), None, Some(1), Some(0)]) .into_array(), @@ -424,7 +429,7 @@ mod tests { /// the dictionary's data buffers once. #[test] fn append_to_dedup_view_builder_adopts_the_dictionary_once() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = VarBinViewArray::from_iter([Some(LONG), Some("short")], DType::Utf8(Nullable)); assert_eq!(values.data_buffers().len(), 1); diff --git a/vortex-array/src/arrays/extension/compute/cast.rs b/vortex-array/src/arrays/extension/compute/cast.rs index e080eb7f04c..5328e897225 100644 --- a/vortex-array/src/arrays/extension/compute/cast.rs +++ b/vortex-array/src/arrays/extension/compute/cast.rs @@ -64,7 +64,7 @@ mod tests { use crate::extension::datetime::TimeUnit; use crate::extension::datetime::Timestamp; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn cast_same_ext_dtype() { diff --git a/vortex-array/src/arrays/extension/compute/mod.rs b/vortex-array/src/arrays/extension/compute/mod.rs index 256f31ac49b..4eb7a774d6b 100644 --- a/vortex-array/src/arrays/extension/compute/mod.rs +++ b/vortex-array/src/arrays/extension/compute/mod.rs @@ -11,12 +11,14 @@ mod take; #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ExtensionArray; use crate::arrays::PrimitiveArray; use crate::compute::conformance::filter::test_filter_conformance; @@ -26,6 +28,8 @@ mod test { use crate::extension::datetime::TimeUnit; use crate::extension::datetime::Timestamp; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_filter_extension_array() { let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable).erased(); @@ -33,20 +37,14 @@ mod test { // Create storage array let storage = buffer![1i32, 2, 3, 4, 5].into_array(); let array = ExtensionArray::new(ext_dtype.clone(), storage); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); // Test with nullable extension type let ext_dtype_nullable = ext_dtype.with_nullability(Nullability::Nullable); let storage = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), None]) .into_array(); let array = ExtensionArray::new(ext_dtype_nullable, storage); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[rstest] @@ -85,21 +83,20 @@ mod test { ExtensionArray::new(ext_dtype_large, storage) })] fn test_take_extension_array_conformance(#[case] array: ExtensionArray) { - test_take_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ExtensionArray; use crate::arrays::PrimitiveArray; use crate::compute::conformance::consistency::test_array_consistency; @@ -107,6 +104,8 @@ mod tests { use crate::extension::datetime::TimeUnit; use crate::extension::datetime::Timestamp; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] // Note: The original test_all_consistency cases for extension arrays caused errors // because of unsupported extension type "uuid". We'll use simpler test cases. @@ -127,9 +126,6 @@ mod tests { ExtensionArray::new(ext_dtype, storage) })] fn test_extension_consistency(#[case] array: ExtensionArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/extension/compute/rules.rs b/vortex-array/src/arrays/extension/compute/rules.rs index b62fc7c8089..fd92940ac6d 100644 --- a/vortex-array/src/arrays/extension/compute/rules.rs +++ b/vortex-array/src/arrays/extension/compute/rules.rs @@ -113,7 +113,7 @@ mod tests { use crate::scalar_fn::fns::binary::Binary; use crate::scalar_fn::fns::operators::Operator; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] struct TestExt; diff --git a/vortex-array/src/arrays/filter/execute/bool.rs b/vortex-array/src/arrays/filter/execute/bool.rs index eb75a11f1d2..bdddb1e70d5 100644 --- a/vortex-array/src/arrays/filter/execute/bool.rs +++ b/vortex-array/src/arrays/filter/execute/bool.rs @@ -23,14 +23,18 @@ pub fn filter_bool(array: &BoolArray, mask: &MaskValuesRef) -> BoolArray { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::filter::execute::bool::BoolArray; use crate::compute::conformance::filter::test_filter_conformance; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(BoolArray::from_iter([true, false, true, true, false]))] #[case(BoolArray::from_iter([Some(true), None, Some(false), Some(true), None]))] @@ -39,9 +43,6 @@ mod tests { #[case(BoolArray::from_iter((0..100).map(|i| i % 2 == 0)))] #[case(BoolArray::from_iter((0..1024).map(|i| i % 3 != 0)))] fn test_filter_bool_conformance(#[case] array: BoolArray) { - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/filter/execute/fixed_size_list.rs b/vortex-array/src/arrays/filter/execute/fixed_size_list.rs index 58334243504..660022a2d1d 100644 --- a/vortex-array/src/arrays/filter/execute/fixed_size_list.rs +++ b/vortex-array/src/arrays/filter/execute/fixed_size_list.rs @@ -107,6 +107,8 @@ fn compute_mask_for_fsl_elements(selection_mask: &MaskValues, list_size: usize) #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rand::RngExt; use rand::SeedableRng; use rand::rngs::StdRng; @@ -114,11 +116,11 @@ mod tests { use vortex_buffer::BitBuffer; use vortex_buffer::buffer; use vortex_mask::Mask; + use vortex_session::VortexSession; use super::compute_mask_for_fsl_elements; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::FixedSizeListArray; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -126,14 +128,13 @@ mod tests { use crate::dtype::Nullability; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_filter_fixed_size_list_conformance() { let elements = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6, 7, 8, 9]); let array = FixedSizeListArray::new(elements.into_array(), 3, Validity::NonNullable, 3); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[test] @@ -142,15 +143,12 @@ mod tests { PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), Some(5), None]); let validity = Validity::from_iter([true, false, true]); let array = FixedSizeListArray::new(elements.into_array(), 2, validity, 3); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[test] fn filter_fixed_size_list_selects_correct_lists() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_iter([10i32, 20, 30, 40, 50, 60]); let array = FixedSizeListArray::new(elements.into_array(), 2, Validity::NonNullable, 3); @@ -167,7 +165,7 @@ mod tests { #[test] fn filter_degenerate_list_size_zero() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::empty::(Nullability::NonNullable); let array = FixedSizeListArray::new(elements.into_array(), 0, Validity::NonNullable, 5); @@ -183,7 +181,7 @@ mod tests { #[test] fn filter_nested_fixed_size_lists() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Inner lists of size 2, outer lists of size 2 (so 2 outer lists, each with 2 inner lists). let inner_elements = buffer![1i32, 2, 3, 4, 5, 6, 7, 8].into_array(); let inner_fsl = FixedSizeListArray::new(inner_elements, 2, Validity::NonNullable, 4); diff --git a/vortex-array/src/arrays/filter/execute/listview.rs b/vortex-array/src/arrays/filter/execute/listview.rs index f6fff6cc807..f002c83d976 100644 --- a/vortex-array/src/arrays/filter/execute/listview.rs +++ b/vortex-array/src/arrays/filter/execute/listview.rs @@ -62,13 +62,12 @@ mod tests { use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ListViewArray; use crate::arrays::PrimitiveArray; use crate::compute::conformance::filter::test_filter_conformance; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_filter_listview_conformance() { diff --git a/vortex-array/src/arrays/filter/execute/mod.rs b/vortex-array/src/arrays/filter/execute/mod.rs index 3bf17f32a1f..2ed36ab128e 100644 --- a/vortex-array/src/arrays/filter/execute/mod.rs +++ b/vortex-array/src/arrays/filter/execute/mod.rs @@ -187,15 +187,19 @@ fn filter_map(array: &MapArray, mask: &MaskValuesRef) -> MapArray { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::BitBuffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::*; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Primitive; use crate::arrays::PrimitiveArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn uncached_contiguous_filter_executes_as_zero_copy_slice() -> VortexResult<()> { let array = PrimitiveArray::from_iter(0i32..128); @@ -209,8 +213,7 @@ mod tests { let filtered = array.into_array().filter(mask)?; assert!(filtered.is::()); - let filtered = - filtered.execute::(&mut array_session().create_execution_ctx())?; + let filtered = filtered.execute::(&mut SESSION.create_execution_ctx())?; let filtered_values = filtered.to_buffer::(); assert_eq!(filtered_values.as_slice(), &(37..91).collect::>()); diff --git a/vortex-array/src/arrays/filter/execute/struct_.rs b/vortex-array/src/arrays/filter/execute/struct_.rs index 69f9bef2d52..0b9c42a0371 100644 --- a/vortex-array/src/arrays/filter/execute/struct_.rs +++ b/vortex-array/src/arrays/filter/execute/struct_.rs @@ -48,11 +48,13 @@ pub fn filter_struct(array: &StructArray, mask: &MaskValuesRef) -> StructArray { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::PrimitiveArray; use crate::arrays::StructArray; @@ -64,6 +66,8 @@ mod tests { use crate::dtype::Nullability::Nullable; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_filter_struct_conformance() { let fields = vec![ @@ -72,10 +76,7 @@ mod tests { ]; let array = StructArray::try_new(["a", "b"].into(), fields, 5, Validity::NonNullable).unwrap(); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[test] @@ -88,15 +89,12 @@ mod tests { ]; let array = StructArray::try_new(["a", "b"].into(), fields, 5, Validity::NonNullable).unwrap(); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[test] fn filter_empty_struct_with_empty_filter() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let struct_arr = StructArray::try_new(FieldNames::empty(), vec![], 0, Validity::NonNullable).unwrap(); let filtered = struct_arr.filter(Mask::from_iter::<[bool; 0]>([])).unwrap(); @@ -112,7 +110,7 @@ mod tests { &StructArray::try_new(FieldNames::empty(), vec![], 5, Validity::NonNullable) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -147,7 +145,7 @@ mod tests { ) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } } diff --git a/vortex-array/src/arrays/filter/execute/take/tests.rs b/vortex-array/src/arrays/filter/execute/take/tests.rs index 54c9f71d884..a1e75d7652f 100644 --- a/vortex-array/src/arrays/filter/execute/take/tests.rs +++ b/vortex-array/src/arrays/filter/execute/take/tests.rs @@ -1,13 +1,15 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_mask::Mask; +use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::DecimalArray; use crate::arrays::Dict; @@ -28,6 +30,8 @@ use crate::executor::ExecutionCtx; use crate::kernel::ExecuteParentKernel; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn execute_parent( child: &crate::ArrayRef, parent: &crate::ArrayRef, @@ -59,7 +63,7 @@ fn test_take_execute_kernel_maps_indices_through_filter() -> VortexResult<()> { filter.clone(), )? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)? .expect("filter child should execute its take parent"); @@ -88,7 +92,7 @@ fn test_take_execute_kernel_nullable_fast_path_maps_indices_through_filter() -> filter.clone(), )? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)? .expect("filter child should execute its take parent"); @@ -110,7 +114,7 @@ fn test_take_execute_kernel_fast_path_maps_indices_through_filter() -> VortexRes ) .into_array(); let parent = DictArray::try_new(buffer![2u64, 0, 3].into_array(), filter.clone())?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)? .expect("filter child should execute its take parent"); @@ -131,7 +135,7 @@ fn assert_take_execute_rejects_out_of_bounds_rank( ) -> VortexResult<()> { let filter = FilterArray::new(child, filter_mask).into_array(); let parent = DictArray::try_new(codes, filter.clone())?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); if let Err(err) = execute_parent(&filter, &parent, 1, &mut ctx) { assert!( @@ -166,7 +170,7 @@ fn test_take_execute_kernel_rejects_random_mask_rank_past_filter_len() -> Vortex #[test] fn test_take_execute_kernel_rejects_non_contiguous_sequential_rank_past_filter_len() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_take_execute_rejects_out_of_bounds_rank( ListArray::try_new( buffer![10u32, 11, 20, 30, 31, 32, 40, 50, 51].into_array(), @@ -182,7 +186,7 @@ fn test_take_execute_kernel_rejects_non_contiguous_sequential_rank_past_filter_l #[test] fn test_take_execute_kernel_rejects_translated_rank_past_filter_len() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_take_execute_rejects_out_of_bounds_rank( ListArray::try_new( buffer![10u32, 11, 20, 30, 31, 32, 40, 50, 51].into_array(), @@ -198,7 +202,7 @@ fn test_take_execute_kernel_rejects_translated_rank_past_filter_len() -> VortexR #[test] fn test_take_execute_kernel_handles_empty_sequential_take() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let filter = FilterArray::new( ListArray::try_new( buffer![10u32, 11, 20, 30, 31, 32, 40, 50, 51].into_array(), @@ -215,7 +219,7 @@ fn test_take_execute_kernel_handles_empty_sequential_take() -> VortexResult<()> filter.clone(), )? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)? .expect("filter child should execute its take parent"); @@ -241,7 +245,7 @@ fn assert_take_execute_maps_child_dtype( let filter = FilterArray::new(child, Mask::from_iter([true, false, true, true, false])).into_array(); let parent = DictArray::try_new(buffer![2u64, 0, 1].into_array(), filter.clone())?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)? .expect("filter child should execute its take parent"); @@ -258,7 +262,7 @@ fn test_take_execute_kernel_skips_bool_filter_child() -> VortexResult<()> { ) .into_array(); let parent = DictArray::try_new(buffer![2u64, 0, 1].into_array(), filter.clone())?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)?; @@ -286,7 +290,7 @@ fn execute_primitive_take( .into_array(); let indices = PrimitiveArray::from_iter((0..take_len).map(|idx| (idx % filtered_len) as u64)); let parent = DictArray::try_new(indices.into_array(), filter.clone())?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)?; let actual = result.as_ref().unwrap_or(&parent); @@ -356,7 +360,7 @@ fn test_take_execute_kernel_handles_nullable_primitive_filter_child() -> VortexR ) .into_array(); let parent = DictArray::try_new(buffer![2u64, 0, 1].into_array(), filter.clone())?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)?; @@ -376,7 +380,7 @@ fn test_take_execute_kernel_preserves_nullable_all_valid_fixed_width_child() -> ) .into_array(); let parent = DictArray::try_new(buffer![0u64, 1].into_array(), filter.clone())?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)? .expect("filter child should execute its take parent"); @@ -403,7 +407,7 @@ fn test_take_execute_kernel_handles_nullable_decimal_filter_child() -> VortexRes ) .into_array(); let parent = DictArray::try_new(buffer![2u64, 0, 1].into_array(), filter.clone())?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)?; @@ -458,7 +462,7 @@ fn test_take_execute_kernel_handles_fixed_size_list_filter_child() -> VortexResu #[test] fn test_take_execute_kernel_handles_list_filter_child() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_take_execute_maps_child_dtype( ListArray::try_new( buffer![10u32, 11, 20, 30, 31, 32, 40, 50, 51].into_array(), @@ -497,7 +501,7 @@ fn test_take_execute_kernel_preserves_nullable_indices_dtype_fast_path() -> Vort filter.clone(), )? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_parent(&filter, &parent, 1, &mut ctx)? .expect("filter child should execute its nullable take parent"); diff --git a/vortex-array/src/arrays/filter/execute/varbinview.rs b/vortex-array/src/arrays/filter/execute/varbinview.rs index 347e278a68d..89b39b51709 100644 --- a/vortex-array/src/arrays/filter/execute/varbinview.rs +++ b/vortex-array/src/arrays/filter/execute/varbinview.rs @@ -38,17 +38,22 @@ pub fn filter_varbinview( #[cfg(test)] mod tests { + use std::sync::LazyLock; + + use vortex_session::VortexSession; + use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinViewArray; use crate::compute::conformance::filter::test_filter_conformance; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_filter_varbinview_conformance() { test_filter_conformance( &VarBinViewArray::from_iter_str(["one", "two", "three", "four", "five"]).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( @@ -60,7 +65,7 @@ mod tests { Some("five"), ]) .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } } diff --git a/vortex-array/src/arrays/fixed_size_list/tests/basic.rs b/vortex-array/src/arrays/fixed_size_list/tests/basic.rs index b471ebb07a0..2fda58d04e7 100644 --- a/vortex-array/src/arrays/fixed_size_list/tests/basic.rs +++ b/vortex-array/src/arrays/fixed_size_list/tests/basic.rs @@ -2,12 +2,13 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use vortex_buffer::buffer; +use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::FixedSizeListArray; use crate::arrays::fixed_size_list::FixedSizeListArrayExt; use crate::arrays::fixed_size_list::FixedSizeListArraySlotsExt; @@ -17,6 +18,8 @@ use crate::dtype::PType; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_basic_fixed_size_list() { let len = 4; @@ -41,19 +44,19 @@ fn test_basic_fixed_size_list() { let first_list = fsl.fixed_size_list_elements_at(0).unwrap(); assert_eq!( first_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 1i32.into() ); assert_eq!( first_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 2i32.into() ); assert_eq!( first_list - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), 3i32.into() ); @@ -61,19 +64,19 @@ fn test_basic_fixed_size_list() { let second_list = fsl.fixed_size_list_elements_at(1).unwrap(); assert_eq!( second_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 4i32.into() ); assert_eq!( second_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 5i32.into() ); assert_eq!( second_list - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), 6i32.into() ); @@ -81,19 +84,19 @@ fn test_basic_fixed_size_list() { let third_list = fsl.fixed_size_list_elements_at(2).unwrap(); assert_eq!( third_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 7i32.into() ); assert_eq!( third_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 8i32.into() ); assert_eq!( third_list - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), 9i32.into() ); @@ -101,19 +104,19 @@ fn test_basic_fixed_size_list() { let fourth_list = fsl.fixed_size_list_elements_at(3).unwrap(); assert_eq!( fourth_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 10i32.into() ); assert_eq!( fourth_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 11i32.into() ); assert_eq!( fourth_list - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), 12i32.into() ); @@ -129,7 +132,7 @@ fn test_scalar_at() { // First list: [1, 2, 3]. let first = fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!( first, @@ -144,26 +147,26 @@ fn test_scalar_at() { let first_list = fsl.fixed_size_list_elements_at(0).unwrap(); assert_eq!( first_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 1i32.into() ); assert_eq!( first_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 2i32.into() ); assert_eq!( first_list - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), 3i32.into() ); // Second list: [4, 5, 6]. let second = fsl - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!( second, @@ -178,19 +181,19 @@ fn test_scalar_at() { let second_list = fsl.fixed_size_list_elements_at(1).unwrap(); assert_eq!( second_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 4i32.into() ); assert_eq!( second_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 5i32.into() ); assert_eq!( second_list - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), 6i32.into() ); @@ -209,13 +212,13 @@ fn test_fixed_size_list_at() { assert_eq!(first_list.len(), list_size as usize); assert_eq!( first_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 1.0f64.into() ); assert_eq!( first_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 2.0f64.into() ); @@ -225,13 +228,13 @@ fn test_fixed_size_list_at() { assert_eq!(third_list.len(), list_size as usize); assert_eq!( third_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 5.0f64.into() ); assert_eq!( third_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 6.0f64.into() ); diff --git a/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs b/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs index 73085b8c8a8..b5dd3c2a2ad 100644 --- a/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs +++ b/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs @@ -2,12 +2,13 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use vortex_buffer::buffer; +use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::FixedSizeListArray; use crate::arrays::PrimitiveArray; use crate::arrays::fixed_size_list::FixedSizeListArrayExt; @@ -18,6 +19,8 @@ use crate::dtype::PType; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + //////////////////////////////////////////////////////////////////////////////////////////////////// // Non-nullable degenerate cases //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -58,7 +61,7 @@ fn test_fsl_size_0_length_1_non_nullable() { // Get the single empty list. let scalar = fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!scalar.is_null()); assert_eq!( @@ -86,7 +89,7 @@ fn test_fsl_size_0_huge_length_non_nullable() { // Spot check a few lists. let scalar_first = fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!scalar_first.is_null()); assert_eq!( @@ -99,7 +102,7 @@ fn test_fsl_size_0_huge_length_non_nullable() { ); let scalar_middle = fsl - .execute_scalar(500_000_000_000, &mut array_session().create_execution_ctx()) + .execute_scalar(500_000_000_000, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!scalar_middle.is_null()); assert_eq!( @@ -112,7 +115,7 @@ fn test_fsl_size_0_huge_length_non_nullable() { ); let scalar_end = fsl - .execute_scalar(999_999_999_999, &mut array_session().create_execution_ctx()) + .execute_scalar(999_999_999_999, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!scalar_end.is_null()); assert_eq!( @@ -164,7 +167,7 @@ fn test_fsl_size_0_length_1_nullable_valid() { // Get the single empty list (should be valid). let scalar = fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!scalar.is_null()); assert_eq!( @@ -189,7 +192,7 @@ fn test_fsl_size_0_length_1_nullable_null() { // The single list should be null. let scalar = fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(scalar.is_null()); } @@ -216,7 +219,7 @@ fn test_fsl_size_0_length_10_nullable_mixed() { ]; for i in 0..len { let scalar = fsl - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(); if expected_valid[i] { assert!(!scalar.is_null()); @@ -257,7 +260,7 @@ fn test_fsl_size_0_nullable_elements() { // All lists should be empty but valid. for i in 0..len { let scalar = fsl - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!scalar.is_null()); } diff --git a/vortex-array/src/arrays/fixed_size_list/tests/filter.rs b/vortex-array/src/arrays/fixed_size_list/tests/filter.rs index 69677400692..b76ed86e536 100644 --- a/vortex-array/src/arrays/fixed_size_list/tests/filter.rs +++ b/vortex-array/src/arrays/fixed_size_list/tests/filter.rs @@ -1,15 +1,17 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::BitBuffer; use vortex_buffer::buffer; use vortex_mask::Mask; +use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::FixedSizeListArray; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -21,6 +23,8 @@ use crate::compute::conformance::filter::test_filter_conformance; use crate::dtype::Nullability; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + // Consolidated parameterized test for degenerate (list_size=0) cases. #[rstest] #[case::basic_degenerate( @@ -53,7 +57,7 @@ fn test_filter_degenerate_list_size_zero( #[case] mask_values: Vec, #[case] expected_len: usize, ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let new_validity = if matches!(validity, Validity::NonNullable) { Validity::NonNullable } else { @@ -82,7 +86,7 @@ fn test_filter_degenerate_list_size_zero( #[test] fn test_filter_with_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_option_iter([Some(1i32), Some(2), None, Some(4), Some(5), Some(6)]); let validity = Validity::from_iter([true, false, true]); @@ -110,7 +114,7 @@ fn test_filter_with_nulls() { #[test] fn test_filter_all_null_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create an array where all elements are null. let elements = buffer![1i32, 2, 3, 4, 5, 6].into_array(); let validity = Validity::AllInvalid; @@ -127,7 +131,7 @@ fn test_filter_all_null_array() { #[test] fn test_filter_nested_fixed_size_lists() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create nested fixed-size lists: FSL>. // Inner lists are of size 2, outer lists are of size 3. // So we have 2 outer lists, each containing 3 inner lists, each containing 2 i32s. @@ -182,7 +186,7 @@ fn test_filter_nested_fixed_size_lists() { #[case(create_fsl_single_element())] #[case(create_fsl_empty())] fn test_filter_fsl_conformance(#[case] array: ArrayRef) { - test_filter_conformance(&array, &mut array_session().create_execution_ctx()); + test_filter_conformance(&array, &mut SESSION.create_execution_ctx()); } // Helper functions for creating test arrays. @@ -253,7 +257,7 @@ fn create_fsl_empty() -> ArrayRef { #[test] fn test_filter_all_null_various_list_sizes() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test filtering with all-null arrays of different list sizes. // The implementation returns ConstantArray only when validity_mask() is Mask::AllFalse. @@ -292,7 +296,7 @@ fn test_filter_all_null_various_list_sizes() { #[test] fn test_mask_expansion_threshold_boundary() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test with list_size == 8 (the FSL_SPARSE_MASK_LIST_SIZE_THRESHOLD). let list_size = 8u32; let num_lists = 100; @@ -369,7 +373,7 @@ fn test_mask_expansion_threshold_boundary() { // Test FSL-specific behavior with very large list sizes. #[test] fn test_filter_large_list_size() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test with list_size=100, which is significantly larger than typical use cases. let list_size = 100u32; let num_lists = 5; diff --git a/vortex-array/src/arrays/fixed_size_list/tests/nested.rs b/vortex-array/src/arrays/fixed_size_list/tests/nested.rs index b754229ff90..ce907d7be64 100644 --- a/vortex-array/src/arrays/fixed_size_list/tests/nested.rs +++ b/vortex-array/src/arrays/fixed_size_list/tests/nested.rs @@ -2,12 +2,13 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use vortex_buffer::buffer; +use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::FixedSizeListArray; use crate::arrays::PrimitiveArray; use crate::arrays::StructArray; @@ -22,6 +23,8 @@ use crate::dtype::StructFields; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + //////////////////////////////////////////////////////////////////////////////////////////////////// // FSL of FSL tests //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -74,7 +77,7 @@ fn test_fsl_of_fsl_basic() { // The first outer list should contain 3 inner lists. // We can check by slicing and examining scalars. let first_scalar = outer_fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!first_scalar.is_null()); @@ -85,19 +88,19 @@ fn test_fsl_of_fsl_basic() { // Check first inner list [1,2]. let inner_list_0 = first_outer_list .clone() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(0) .unwrap(); assert_eq!( inner_list_0 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 1i32.into() ); assert_eq!( inner_list_0 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 2i32.into() ); @@ -105,38 +108,38 @@ fn test_fsl_of_fsl_basic() { // Check second inner list [3,4]. let inner_list_1 = first_outer_list .clone() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(1) .unwrap(); assert_eq!( inner_list_1 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 3i32.into() ); assert_eq!( inner_list_1 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 4i32.into() ); // Check third inner list [5,6]. let inner_list_2 = first_outer_list - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(2) .unwrap(); assert_eq!( inner_list_2 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 5i32.into() ); assert_eq!( inner_list_2 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 6i32.into() ); @@ -147,19 +150,19 @@ fn test_fsl_of_fsl_basic() { // Check first inner list [7,8]. let inner_list_0 = second_outer_list .clone() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(0) .unwrap(); assert_eq!( inner_list_0 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 7i32.into() ); assert_eq!( inner_list_0 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 8i32.into() ); @@ -167,38 +170,38 @@ fn test_fsl_of_fsl_basic() { // Check second inner list [9,10]. let inner_list_1 = second_outer_list .clone() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(1) .unwrap(); assert_eq!( inner_list_1 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 9i32.into() ); assert_eq!( inner_list_1 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 10i32.into() ); // Check third inner list [11,12]. let inner_list_2 = second_outer_list - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(2) .unwrap(); assert_eq!( inner_list_2 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 11i32.into() ); assert_eq!( inner_list_2 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 12i32.into() ); @@ -248,7 +251,7 @@ fn test_fsl_of_fsl_with_nulls() { // First outer list is valid. assert!( !outer_fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); @@ -256,7 +259,7 @@ fn test_fsl_of_fsl_with_nulls() { // Second outer list is null. assert!( outer_fsl - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); @@ -264,7 +267,7 @@ fn test_fsl_of_fsl_with_nulls() { // Third outer list is valid. assert!( !outer_fsl - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); @@ -311,12 +314,12 @@ fn test_deeply_nested_fsl() { let top_level = level3.fixed_size_list_elements_at(0).unwrap(); let level2_0 = top_level .clone() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(0) .unwrap(); let level2_1 = top_level - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(1) .unwrap(); @@ -324,37 +327,37 @@ fn test_deeply_nested_fsl() { // First level-2 list: [[1,2],[3,4]]. let level1_0_0 = level2_0 .clone() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(0) .unwrap(); assert_eq!( level1_0_0 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 1i32.into() ); assert_eq!( level1_0_0 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 2i32.into() ); let level1_0_1 = level2_0 - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(1) .unwrap(); assert_eq!( level1_0_1 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 3i32.into() ); assert_eq!( level1_0_1 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 4i32.into() ); @@ -362,37 +365,37 @@ fn test_deeply_nested_fsl() { // Second level-2 list: [[5,6],[7,8]]. let level1_1_0 = level2_1 .clone() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(0) .unwrap(); assert_eq!( level1_1_0 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 5i32.into() ); assert_eq!( level1_1_0 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 6i32.into() ); let level1_1_1 = level2_1 - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap() .fixed_size_list_elements_at(1) .unwrap(); assert_eq!( level1_1_1 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 7i32.into() ); assert_eq!( level1_1_1 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 8i32.into() ); diff --git a/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs b/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs index e26d5b85e49..ad73acd7b35 100644 --- a/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs +++ b/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs @@ -2,12 +2,13 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use vortex_buffer::buffer; +use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::FixedSizeListArray; use crate::arrays::PrimitiveArray; @@ -18,6 +19,8 @@ use crate::dtype::PType; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_nullable_fsl_with_nulls() { let len = 4; @@ -33,7 +36,7 @@ fn test_nullable_fsl_with_nulls() { // First list is valid: [1, 2]. let first = fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!first.is_null()); assert_eq!( @@ -49,26 +52,26 @@ fn test_nullable_fsl_with_nulls() { let first_list = fsl.fixed_size_list_elements_at(0).unwrap(); assert_eq!( first_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 1i32.into() ); assert_eq!( first_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 2i32.into() ); // Second list is null. let second = fsl - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(second.is_null()); // Third list is valid: [5, 6]. let third = fsl - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!third.is_null()); assert_eq!( @@ -84,20 +87,20 @@ fn test_nullable_fsl_with_nulls() { let third_list = fsl.fixed_size_list_elements_at(2).unwrap(); assert_eq!( third_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 5i32.into() ); assert_eq!( third_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 6i32.into() ); // Fourth list is null. let fourth = fsl - .execute_scalar(3, &mut array_session().create_execution_ctx()) + .execute_scalar(3, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(fourth.is_null()); } @@ -123,7 +126,7 @@ fn test_nullable_elements_non_nullable_lists() { // First list: [Some(1), None, Some(3)]. let first = fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!first.is_null()); assert_eq!( @@ -137,7 +140,7 @@ fn test_nullable_elements_non_nullable_lists() { // Second list: [Some(4), Some(5), None]. let second = fsl - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!second.is_null()); assert_eq!( @@ -165,7 +168,7 @@ fn test_nullable_elements_and_nullable_lists() { // First list is valid: [Some(10), None]. let first = fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!first.is_null()); assert_eq!( @@ -181,26 +184,26 @@ fn test_nullable_elements_and_nullable_lists() { let first_list = fsl.fixed_size_list_elements_at(0).unwrap(); assert_eq!( first_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Some(10u16).into() ); assert_eq!( first_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), None::.into() ); // Second list is null (but elements would be [Some(20), Some(30)]). let second = fsl - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(second.is_null()); // Third list is valid: [None, None]. let third = fsl - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!third.is_null()); assert_eq!( @@ -216,13 +219,13 @@ fn test_nullable_elements_and_nullable_lists() { let third_list = fsl.fixed_size_list_elements_at(2).unwrap(); assert_eq!( third_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), None::.into() ); assert_eq!( third_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), None::.into() ); @@ -243,7 +246,7 @@ fn test_alternating_nulls() { // Check alternating pattern. for i in 0..len { let scalar = fsl - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(); if i % 2 == 0 { assert!(!scalar.is_null()); @@ -275,7 +278,7 @@ fn test_validity_types() { let fsl = FixedSizeListArray::new(elements.clone(), list_size, Validity::AllInvalid, len); for i in 0..len { assert!( - fsl.execute_scalar(i, &mut array_session().create_execution_ctx()) + fsl.execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); @@ -293,22 +296,22 @@ fn test_validity_types() { ); assert!( - !fsl.execute_scalar(0, &mut array_session().create_execution_ctx()) + !fsl.execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert!( - !fsl.execute_scalar(1, &mut array_session().create_execution_ctx()) + !fsl.execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert!( - fsl.execute_scalar(2, &mut array_session().create_execution_ctx()) + fsl.execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert!( - !fsl.execute_scalar(3, &mut array_session().create_execution_ctx()) + !fsl.execute_scalar(3, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); @@ -338,31 +341,31 @@ fn test_mixed_nullability_patterns() { // List 0: valid with [Some(1), None]. let list0 = fsl - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!list0.is_null()); // List 1: null. let list1 = fsl - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(list1.is_null()); // List 2: valid with [Some(5), Some(6)]. let list2 = fsl - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!list2.is_null()); // List 3: valid with [Some(7), None]. let list3 = fsl - .execute_scalar(3, &mut array_session().create_execution_ctx()) + .execute_scalar(3, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!list3.is_null()); // List 4: valid with [None, Some(10)]. let list4 = fsl - .execute_scalar(4, &mut array_session().create_execution_ctx()) + .execute_scalar(4, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!list4.is_null()); let element_dtype = Arc::new(DType::Primitive(PType::I16, Nullability::Nullable)); diff --git a/vortex-array/src/arrays/fixed_size_list/tests/take.rs b/vortex-array/src/arrays/fixed_size_list/tests/take.rs index afc6f845fb9..640ce87ea21 100644 --- a/vortex-array/src/arrays/fixed_size_list/tests/take.rs +++ b/vortex-array/src/arrays/fixed_size_list/tests/take.rs @@ -1,10 +1,13 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use super::common::create_basic_fsl; use super::common::create_empty_fsl; @@ -15,7 +18,6 @@ use crate::ArrayRef; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::ConstantArray; use crate::arrays::FixedSizeListArray; use crate::arrays::PiecewiseSequenceArray; @@ -30,6 +32,8 @@ use crate::dtype::PType; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + // Conformance tests for common take scenarios. #[rstest] #[case::basic(create_basic_fsl())] @@ -38,17 +42,14 @@ use crate::validity::Validity; #[case::single_element(create_single_element_fsl())] #[case::empty(create_empty_fsl())] fn test_take_fsl_conformance(#[case] fsl: FixedSizeListArray) { - test_take_conformance( - &fsl.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&fsl.into_array(), &mut SESSION.create_execution_ctx()); } // FSL-specific edge case tests that aren't covered by conformance. #[test] fn test_take_basic_smoke_test() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![1i32, 2, 3, 4, 5, 6].into_array(); let fsl = FixedSizeListArray::new(elements.into_array(), 2, Validity::NonNullable, 3); @@ -98,7 +99,7 @@ fn test_take_degenerate_lists( test_take_conformance( &fsl.clone().into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); // Also test the specific behavior. @@ -109,7 +110,7 @@ fn test_take_degenerate_lists( for (i, expected_null) in expected_nulls.iter().enumerate() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap() .is_null(), *expected_null @@ -119,7 +120,7 @@ fn test_take_degenerate_lists( #[test] fn test_take_large_list_size() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![0i32..300].into_array(); let fsl = FixedSizeListArray::new(elements, 100, Validity::NonNullable, 3); @@ -134,7 +135,7 @@ fn test_take_large_list_size() { #[test] fn test_take_fsl_with_null_indices_preserves_elements() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![1i32, 2, 3, 4, 5, 6].into_array(); let fsl = FixedSizeListArray::new(elements.into_array(), 2, Validity::NonNullable, 3); @@ -154,7 +155,7 @@ fn test_take_fsl_with_null_indices_preserves_elements() { #[test] fn test_take_fsl_null_index_ignores_out_of_bounds_payload() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![1i32, 2, 3, 4, 5, 6].into_array(); let fsl = FixedSizeListArray::new(elements.into_array(), 2, Validity::NonNullable, 3); @@ -207,7 +208,7 @@ fn test_take_piecewise( #[case] lengths: &[u64], #[case] expanded: &[u64], ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl = nullable_fsl_i32(); let result = fsl.take(contiguous_pieces(starts, lengths)?)?; @@ -219,7 +220,7 @@ fn test_take_piecewise( #[test] fn test_take_piecewise_out_of_bounds() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl = nullable_fsl_i32(); let indices = contiguous_pieces(&[2], &[3])?; @@ -233,7 +234,7 @@ fn test_take_piecewise_out_of_bounds() -> VortexResult<()> { #[test] fn test_take_piecewise_non_unit_multiplier() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl = nullable_fsl_i32(); // Multiplier 2 falls back to the generic path but must stay correct. @@ -280,7 +281,7 @@ fn test_element_index_overflow( #[case] indices: ArrayRef, #[case] expected: FixedSizeListArray, ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = fsl.take(indices).unwrap(); assert_arrays_eq!(result, expected, &mut ctx); } @@ -346,7 +347,7 @@ fn test_take_nullable_arrays_fsl_specific( for (i, expected_null) in expected_nulls.iter().enumerate() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap() .is_null(), *expected_null diff --git a/vortex-array/src/arrays/fixed_width/filter/tests.rs b/vortex-array/src/arrays/fixed_width/filter/tests.rs index dbb74db1d0b..03bd00e3890 100644 --- a/vortex-array/src/arrays/fixed_width/filter/tests.rs +++ b/vortex-array/src/arrays/fixed_width/filter/tests.rs @@ -1,6 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; use std::sync::atomic::Ordering; use rstest::rstest; @@ -8,12 +9,12 @@ use vortex_buffer::Buffer; use vortex_buffer::BufferAllocatorRef; use vortex_buffer::buffer; use vortex_mask::Mask; +use vortex_session::VortexSession; use super::filter_records; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::DecimalArray; use crate::arrays::PrimitiveArray; use crate::compute::conformance::filter::LARGE_SIZE; @@ -24,6 +25,8 @@ use crate::dtype::i256; use crate::memory::test_allocator::counting_allocator; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn filter_fallback_width_records() { let Mask::Values(mask) = Mask::from_iter([true, false, true, false]) else { @@ -102,5 +105,5 @@ fn filter_records_use_execution_allocator() { Validity::NonNullable, ).into_array())] fn fixed_width_filter_conformance(#[case] array: ArrayRef) { - test_filter_conformance(&array, &mut array_session().create_execution_ctx()); + test_filter_conformance(&array, &mut SESSION.create_execution_ctx()); } diff --git a/vortex-array/src/arrays/fixed_width/take/tests.rs b/vortex-array/src/arrays/fixed_width/take/tests.rs index 37d526e2d97..e2d9b192977 100644 --- a/vortex-array/src/arrays/fixed_width/take/tests.rs +++ b/vortex-array/src/arrays/fixed_width/take/tests.rs @@ -1,11 +1,14 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::BufferAllocatorRef; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use super::records::take_byte_records; use super::slices::take_slices; @@ -14,7 +17,6 @@ use super::take_values; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::DecimalArray; @@ -26,6 +28,8 @@ use crate::dtype::DecimalDType; use crate::dtype::i256; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn allocator() -> BufferAllocatorRef { BufferAllocatorRef::statically_allocated() } @@ -136,7 +140,7 @@ fn take_constant_length_slices() -> VortexResult<()> { #[test] fn null_index_skips_out_of_bounds_primitive_value() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::from_iter([10i32, 20, 30]); let indices = PrimitiveArray::new( buffer![1u64, 3], @@ -155,7 +159,7 @@ fn null_index_skips_out_of_bounds_primitive_value() -> VortexResult<()> { #[test] fn null_index_skips_out_of_bounds_decimal_value() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(19, 1); let values = DecimalArray::new( buffer![10i128, 20, 30], @@ -179,7 +183,7 @@ fn null_index_skips_out_of_bounds_decimal_value() -> VortexResult<()> { #[test] fn decimal_i256_take_consumes_piecewise_indices() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(76, 2); let values = DecimalArray::new( buffer![ @@ -247,5 +251,5 @@ fn decimal_i256_take_consumes_piecewise_indices() -> VortexResult<()> { Validity::NonNullable, ).into_array())] fn fixed_width_take_conformance(#[case] array: ArrayRef) { - test_take_conformance(&array, &mut array_session().create_execution_ctx()); + test_take_conformance(&array, &mut SESSION.create_execution_ctx()); } diff --git a/vortex-array/src/arrays/interleave/mod.rs b/vortex-array/src/arrays/interleave/mod.rs index f59e0a423be..d5cb8085dbc 100644 --- a/vortex-array/src/arrays/interleave/mod.rs +++ b/vortex-array/src/arrays/interleave/mod.rs @@ -310,14 +310,16 @@ fn value_validity_array(value: &ArrayRef) -> VortexResult { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::*; use crate::AnyColumnar; use crate::Canonical; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Bool; use crate::arrays::BoolArray; use crate::arrays::Primitive; @@ -326,6 +328,8 @@ mod tests { use crate::assert_arrays_eq; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[derive(Clone, Copy)] enum LazyChild { ArraySelector, @@ -393,7 +397,7 @@ mod tests { let interleaved = InterleaveArray::try_new(values, array_indices, row_indices)?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(interleaved, expected, &mut ctx); Ok(()) } @@ -484,7 +488,7 @@ mod tests { InterleaveArray::try_new(values.clone(), array_indices.clone(), row_indices.clone())? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let reference = interleave_reference(&values, &array_indices, &row_indices, &mut ctx)?; assert_arrays_eq!(interleaved, reference, &mut ctx); @@ -622,7 +626,7 @@ mod tests { InterleaveArray::try_new(vec![value.clone(), value], array_indices, row_indices)? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let err = interleaved .execute::(&mut ctx) .err() @@ -643,7 +647,7 @@ mod tests { InterleaveArray::try_new(vec![value.clone(), value], array_indices, row_indices)? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let err = interleaved .execute::(&mut ctx) .err() @@ -663,7 +667,7 @@ mod tests { let expected = PrimitiveArray::from_option_iter([Some(1.0f64), Some(10.0), Some(2.0), None]) .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(interleaved, expected, &mut ctx); Ok(()) } @@ -678,7 +682,7 @@ mod tests { InterleaveArray::try_new(vec![constant, column], array_indices, row_indices)? .into_array(); let expected = PrimitiveArray::from_iter([1.0f64, 10.0, 1.0, 20.0]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(interleaved, expected, &mut ctx); Ok(()) @@ -699,7 +703,7 @@ mod tests { .into_array(); let expected = PrimitiveArray::from_option_iter([None, Some(10.0f64), None, Some(20.0)]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(interleaved, expected, &mut ctx); Ok(()) diff --git a/vortex-array/src/arrays/list/array.rs b/vortex-array/src/arrays/list/array.rs index c0929bce12d..377499faea6 100644 --- a/vortex-array/src/arrays/list/array.rs +++ b/vortex-array/src/arrays/list/array.rs @@ -81,6 +81,7 @@ pub struct ListSlots { /// use vortex_array::arrays::{ListArray, PrimitiveArray}; /// use vortex_array::arrays::list::ListArrayExt; /// use vortex_array::validity::Validity; +/// use vortex_session::VortexSession; /// use vortex_array::{IntoArray, VortexSessionExecute}; /// use vortex_buffer::buffer; /// use std::sync::Arc; @@ -89,7 +90,7 @@ pub struct ListSlots { /// let elements = buffer![1i32, 2, 3, 4, 5].into_array(); /// let offsets = buffer![0u32, 2, 5, 5].into_array(); // 3 lists /// -/// let mut ctx = vortex_array::array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// let list_array = ListArray::try_new( /// elements.into_array(), /// offsets.into_array(), diff --git a/vortex-array/src/arrays/list/compute/cast.rs b/vortex-array/src/arrays/list/compute/cast.rs index 15b7abd5c23..8ecd998dbd4 100644 --- a/vortex-array/src/arrays/list/compute/cast.rs +++ b/vortex-array/src/arrays/list/compute/cast.rs @@ -85,7 +85,7 @@ mod tests { use crate::dtype::PType; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_cast_list_success() { diff --git a/vortex-array/src/arrays/list/compute/mod.rs b/vortex-array/src/arrays/list/compute/mod.rs index 1cef40cfbfa..8d98dc684ff 100644 --- a/vortex-array/src/arrays/list/compute/mod.rs +++ b/vortex-array/src/arrays/list/compute/mod.rs @@ -15,12 +15,14 @@ pub(crate) fn initialize(session: &vortex_session::VortexSession) { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ListArray; use crate::arrays::PrimitiveArray; @@ -29,9 +31,11 @@ mod tests { use crate::compute::conformance::mask::test_mask_conformance; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_mask_list() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![0..35].into_array(); let offsets = buffer![0, 5, 11, 18, 26, 35].into_array(); let validity = Validity::AllValid; @@ -43,15 +47,12 @@ mod tests { ) .unwrap(); - test_mask_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_mask_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[test] fn test_filter_list() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![0..35].into_array(); let offsets = buffer![0, 5, 11, 18, 26, 35].into_array(); let validity = Validity::AllValid; @@ -63,10 +64,7 @@ mod tests { ) .unwrap(); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[rstest] @@ -75,37 +73,34 @@ mod tests { buffer![0i32, 1, 2, 3, 4, 5].into_array(), buffer![0, 2, 3, 5, 5, 6].into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] #[case::list_nullable(ListArray::try_new( buffer![10i32, 20, 30, 40, 50].into_array(), buffer![0, 2, 3, 4, 5].into_array(), Validity::Array(BoolArray::from_iter(vec![true, false, true, true]).into_array()), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] // Additional test cases #[case::list_empty_lists(ListArray::try_new( buffer![100i32, 200, 300].into_array(), buffer![0, 0, 2, 2, 3, 3].into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] #[case::list_single_element(ListArray::try_new( buffer![42i32].into_array(), buffer![0, 1].into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] #[case::list_large(ListArray::try_new( buffer![0..1000i32].into_array(), PrimitiveArray::from_iter((0..=100).map(|i| i * 10)).into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] fn test_list_consistency(#[case] array: ListArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/list/compute/take.rs b/vortex-array/src/arrays/list/compute/take.rs index 6fb983cc106..591e1cf638d 100644 --- a/vortex-array/src/arrays/list/compute/take.rs +++ b/vortex-array/src/arrays/list/compute/take.rs @@ -847,14 +847,15 @@ fn new_offset_value(value: usize) -> T { #[cfg(test)] mod test { use std::sync::Arc; + use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray as _; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::ListArray; @@ -870,9 +871,11 @@ mod test { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn nullable_take() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( buffer![0i32, 5, 3, 4].into_array(), buffer![0, 2, 3, 4, 4].into_array(), @@ -903,12 +906,12 @@ mod test { assert!( result - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_eq!( result - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::list( Arc::clone(&element_dtype), @@ -919,18 +922,18 @@ mod test { assert!( result - .is_invalid(1, &mut array_session().create_execution_ctx()) + .is_invalid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); assert!( result - .is_valid(2, &mut array_session().create_execution_ctx()) + .is_valid(2, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_eq!( result - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::list( Arc::clone(&element_dtype), @@ -941,12 +944,12 @@ mod test { assert!( result - .is_valid(3, &mut array_session().create_execution_ctx()) + .is_valid(3, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_eq!( result - .execute_scalar(3, &mut array_session().create_execution_ctx()) + .execute_scalar(3, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::list(element_dtype, vec![], Nullability::Nullable) ); @@ -954,7 +957,7 @@ mod test { #[test] fn null_index_ignores_out_of_bounds_payload() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( buffer![1i32, 2, 3, 4].into_array(), buffer![0u32, 2, 4].into_array(), @@ -982,7 +985,7 @@ mod test { #[test] fn null_source_row_uses_valid_empty_output_range() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::new( buffer![1i32, 2, 7, 8].into_array(), buffer![0u32, 2, 4].into_array(), @@ -1005,7 +1008,7 @@ mod test { #[test] fn change_validity() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( buffer![0i32, 5, 3, 4].into_array(), buffer![0, 2, 3].into_array(), @@ -1032,16 +1035,12 @@ mod test { Validity::from_iter([true, true, false]), &mut ctx, ); - assert_arrays_eq!( - result, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(result, expected, &mut SESSION.create_execution_ctx()); } #[test] fn non_nullable_take() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( buffer![0i32, 5, 3, 4].into_array(), buffer![0, 2, 3, 3, 4].into_array(), @@ -1071,12 +1070,12 @@ mod test { assert!( result - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_eq!( result - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::list( Arc::clone(&element_dtype), @@ -1087,12 +1086,12 @@ mod test { assert!( result - .is_valid(1, &mut array_session().create_execution_ctx()) + .is_valid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_eq!( result - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::list( Arc::clone(&element_dtype), @@ -1103,12 +1102,12 @@ mod test { assert!( result - .is_valid(2, &mut array_session().create_execution_ctx()) + .is_valid(2, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_eq!( result - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::list(element_dtype, vec![], Nullability::NonNullable) ); @@ -1116,7 +1115,7 @@ mod test { #[test] fn piecewise_sequence_take() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( buffer![0i32, 1, 2, 3, 4, 5, 6].into_array(), buffer![0u32, 2, 5, 5, 7].into_array(), @@ -1165,7 +1164,7 @@ mod test { #[test] fn piecewise_sequence_take_nullable_list_constant_lengths() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( buffer![0i32, 1, 99, 100, 2, 3, 4, 5].into_array(), buffer![0u32, 2, 4, 7, 8].into_array(), @@ -1218,7 +1217,7 @@ mod test { #[test] fn piecewise_sequence_take_nullable_list_array_lengths() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( buffer![0i32, 1, 99, 100, 2, 3, 4, 5].into_array(), buffer![0u32, 2, 4, 7, 8].into_array(), @@ -1265,7 +1264,7 @@ mod test { #[test] fn test_take_empty_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( buffer![0i32, 5, 3, 4].into_array(), buffer![0].into_array(), @@ -1293,25 +1292,25 @@ mod test { buffer![0i32, 1, 2, 3, 4, 5].into_array(), buffer![0, 2, 3, 5, 5, 6].into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] #[case(ListArray::try_new( buffer![10i32, 20, 30, 40, 50].into_array(), buffer![0, 2, 3, 4, 5].into_array(), Validity::Array(BoolArray::from_iter(vec![true, false, true, true]).into_array()), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] #[case(ListArray::try_new( buffer![1i32, 2, 3].into_array(), buffer![0, 0, 2, 2, 3].into_array(), // First and third are empty Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] #[case(ListArray::try_new( buffer![42i32, 43].into_array(), buffer![0, 2].into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] #[case({ let elements = buffer![0i32..200].into_array(); @@ -1323,25 +1322,22 @@ mod test { elements, PrimitiveArray::from_iter(offsets).into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() })] #[case(ListArray::try_new( PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), None]).into_array(), buffer![0, 2, 3, 5].into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap())] fn test_take_list_conformance(#[case] list: ListArray) { - test_take_conformance( - &list.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&list.into_array(), &mut SESSION.create_execution_ctx()); } #[test] fn test_u64_offset_accumulation_non_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![0i32; 200].into_array(); let offsets = buffer![0u8, 200].into_array(); let list = ListArray::try_new(elements, offsets, Validity::NonNullable, &mut ctx) @@ -1358,12 +1354,12 @@ mod test { assert_eq!(result_view.len(), 2); assert!( result_view - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); assert!( result_view - .is_valid(1, &mut array_session().create_execution_ctx()) + .is_valid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); let expected = ListArray::new( @@ -1377,7 +1373,7 @@ mod test { #[test] fn test_u64_offset_accumulation_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![0i32; 150].into_array(); let offsets = buffer![0u8, 150, 150].into_array(); let validity = BoolArray::from_iter(vec![true, false]).into_array(); @@ -1395,17 +1391,17 @@ mod test { assert_eq!(result_view.len(), 3); assert!( result_view - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); assert!( result_view - .is_invalid(1, &mut array_session().create_execution_ctx()) + .is_invalid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); assert!( result_view - .is_valid(2, &mut array_session().create_execution_ctx()) + .is_valid(2, &mut SESSION.create_execution_ctx()) .unwrap() ); let expected = ListArray::new( @@ -1423,7 +1419,7 @@ mod test { /// the result validity must have length equal to indices.len(), not source.len(). #[test] fn test_take_validity_length_mismatch_regression() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Source array with explicit validity array (length 2). let list = ListArray::try_new( buffer![1i32, 2, 3, 4].into_array(), @@ -1446,10 +1442,6 @@ mod test { Validity::AllValid, &mut ctx, ); - assert_arrays_eq!( - result, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(result, expected, &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/list/tests.rs b/vortex-array/src/arrays/list/tests.rs index d6002a03122..08792fc251a 100644 --- a/vortex-array/src/arrays/list/tests.rs +++ b/vortex-array/src/arrays/list/tests.rs @@ -14,7 +14,6 @@ use vortex_session::VortexSession; use super::*; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::FilterArray; use crate::arrays::List; use crate::arrays::PrimitiveArray; @@ -28,7 +27,7 @@ use crate::scalar::Scalar; use crate::validity::Validity; /// A shared session for `List` tests, used to create execution contexts. -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_empty_list_array() { @@ -423,7 +422,7 @@ fn test_list_filter_variable_sizes() { #[test] fn test_offset_to_0() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ListBuilder::::with_capacity_in( Arc::new(I32.into()), Nullability::NonNullable, @@ -773,7 +772,7 @@ fn test_list_of_lists_nullable_outer() { #[test] fn test_list_of_lists_nullable_inner() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create list of lists with non-nullable outer, nullable inner. // Structure: [[[1, 2], null, [3]], [[4, 5, 6]], [], [[null, 7]]] let data = vec![ @@ -963,7 +962,7 @@ fn test_non_integer_offsets() { #[test] fn test_offsets_constant() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![1i32, 2, 3, 4, 5].into_array(); let offsets = buffer![5u32, 5, 5, 5].into_array(); let validity = Validity::AllValid; diff --git a/vortex-array/src/arrays/listview/array.rs b/vortex-array/src/arrays/listview/array.rs index 4179bceff1e..bebd5df30fe 100644 --- a/vortex-array/src/arrays/listview/array.rs +++ b/vortex-array/src/arrays/listview/array.rs @@ -92,6 +92,7 @@ pub struct ListViewSlots { /// # use vortex_array::arrays::{ListViewArray, PrimitiveArray}; /// # use vortex_array::arrays::listview::ListViewArrayExt; /// # use vortex_array::validity::Validity; +/// # use vortex_session::VortexSession; /// # use vortex_array::{IntoArray, VortexSessionExecute}; /// # use vortex_buffer::buffer; /// # use std::sync::Arc; @@ -103,7 +104,7 @@ pub struct ListViewSlots { /// let offsets = buffer![2u32, 0, 1].into_array(); // Out-of-order offsets /// let sizes = buffer![2u32, 1, 2].into_array(); // The sizes cause overlaps /// -/// let mut ctx = vortex_array::array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// let list_view = ListViewArray::new( /// elements.into_array(), /// offsets.into_array(), diff --git a/vortex-array/src/arrays/listview/compute/zip.rs b/vortex-array/src/arrays/listview/compute/zip.rs index fc9732c9dc1..a50f1909395 100644 --- a/vortex-array/src/arrays/listview/compute/zip.rs +++ b/vortex-array/src/arrays/listview/compute/zip.rs @@ -237,15 +237,17 @@ mod tests { reason = "test fixtures use small indices that fit the target widths" )] + use std::sync::LazyLock; + use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::Chunked; use crate::arrays::ChunkedArray; @@ -260,13 +262,15 @@ mod tests { use crate::dtype::PType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn list_view( elements: ArrayRef, offsets: ArrayRef, sizes: ArrayRef, validity: Validity, ) -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); ListViewArray::try_new(elements, offsets, sizes, validity, &mut ctx) .unwrap() .into_array() @@ -275,7 +279,7 @@ mod tests { /// `zip` of two list views selects whole lists per the mask and keeps the list encoding. #[test] fn zip_selects_lists() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // [[1, 2], [3], [4, 5, 6]] let if_true = list_view( buffer![1i32, 2, 3, 4, 5, 6].into_array(), @@ -314,7 +318,7 @@ mod tests { /// `zip` selects list-level validity from the chosen side and widens nullability. #[test] fn zip_selects_validity() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // [[1], null, [2]] (list-level nulls) let if_true = list_view( buffer![1i32, 2].into_array(), @@ -349,7 +353,7 @@ mod tests { /// is nullable. #[test] fn zip_out_of_order_offsets_and_widening() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // [[5, 6], [7], [8, 9]] expressed with out-of-order offsets. let if_true = list_view( buffer![7i32, 8, 9, 5, 6].into_array(), @@ -387,7 +391,7 @@ mod tests { /// loop and the trailing remainder, including the `false_shift` applied to `if_false` views. #[test] fn zip_spans_multiple_mask_chunks() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // 130 single-element lists per side: `if_true[i] = [i]`, `if_false[i] = [1000 + i]`. let len = 130usize; let true_elements: Vec = (0..len as i32).collect(); @@ -467,7 +471,7 @@ mod tests { /// aligned chunk body and the suffix. #[test] fn zip_handles_offset_mask() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // 200 single-element lists per side: `if_true[i] = [i]`, `if_false[i] = [1000 + i]`. With a // 3-bit lead offset the mask spans more than 16 bytes, so `unaligned_chunks` exposes a // non-empty aligned `chunks` body between the prefix and suffix words. @@ -529,7 +533,7 @@ mod tests { /// than nesting a chunked array inside the concatenated elements. #[test] fn zip_flattens_chunked_elements() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // elements [1, 2, 3] stored as two chunks; lists [[1, 2], [3]]. let chunked_elements = ChunkedArray::try_new( vec![buffer![1i32, 2].into_array(), buffer![3i32].into_array()], diff --git a/vortex-array/src/arrays/listview/conversion.rs b/vortex-array/src/arrays/listview/conversion.rs index bf41fd3c1db..489c2251702 100644 --- a/vortex-array/src/arrays/listview/conversion.rs +++ b/vortex-array/src/arrays/listview/conversion.rs @@ -312,7 +312,6 @@ mod tests { use crate::EqMode; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::FixedSizeList; use crate::arrays::FixedSizeListArray; @@ -410,7 +409,7 @@ mod tests { #[test] fn test_empty_array_conversions() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Empty ListArray to ListViewArray. let empty_elements = PrimitiveArray::from_iter::<[i32; 0]>([]).into_array(); let empty_offsets = buffer![0u32].into_array(); @@ -837,7 +836,7 @@ mod tests { /// zero-copyable. #[test] fn test_empty_listview_to_list_without_zctl_flag() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = VarBinViewArray::from_iter_str(Vec::<&str>::new()).into_array(); let offsets = PrimitiveArray::from_iter(Vec::::new()).into_array(); let sizes = PrimitiveArray::from_iter(Vec::::new()).into_array(); diff --git a/vortex-array/src/arrays/listview/rebuild.rs b/vortex-array/src/arrays/listview/rebuild.rs index dd32fc265b7..0fe73d4f0ad 100644 --- a/vortex-array/src/arrays/listview/rebuild.rs +++ b/vortex-array/src/arrays/listview/rebuild.rs @@ -462,7 +462,6 @@ mod tests { use super::ListViewRebuildMode; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ListViewArray; use crate::arrays::PrimitiveArray; use crate::arrays::listview::ListViewArrayExt; @@ -473,7 +472,7 @@ mod tests { #[test] fn test_rebuild_flatten_removes_overlaps() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create a list view with overlapping lists: [A, B, C] // List 0: offset=0, size=3 -> [A, B, C] // List 1: offset=1, size=2 -> [B, C] (overlaps with List 0) @@ -514,7 +513,7 @@ mod tests { #[test] fn test_rebuild_flatten_with_nullable() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); use crate::arrays::BoolArray; // Create a nullable list view with a null list @@ -596,7 +595,7 @@ mod tests { #[case::trim_elements(ListViewRebuildMode::TrimElements)] #[case::make_exact(ListViewRebuildMode::MakeExact)] fn test_rebuild_empty_drops_elements(#[case] mode: ListViewRebuildMode) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // No lists, but three elements left in the buffer. let listview = ListViewArray::new( PrimitiveArray::from_iter([1i32, 2, 3]).into_array(), @@ -615,7 +614,7 @@ mod tests { #[test] fn test_rebuild_trim_elements_basic() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test trimming both leading and trailing unused elements while preserving gaps in the // middle. // Elements: [_, _, A, B, _, C, D, _, _] @@ -697,7 +696,7 @@ mod tests { #[test] fn test_rebuild_with_trailing_nulls_regression() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Regression test for issue #5412 // Tests that zero-copy-to-list arrays with trailing NULLs correctly calculate // offsets for NULL items to maintain no-overlap invariant @@ -757,7 +756,7 @@ mod tests { /// u32 offsets exceed u16::MAX, so u16 sizes are widened to u32 for the add. #[test] fn test_rebuild_trim_elements_offsets_wider_than_sizes() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut elems = vec![0i32; 70_005]; elems[70_000] = 10; elems[70_001] = 20; @@ -783,7 +782,7 @@ mod tests { /// u32 sizes exceed u16::MAX, so u16 offsets are widened to u32 for the add. #[test] fn test_rebuild_trim_elements_sizes_wider_than_offsets() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut elems = vec![0i32; 70_001]; elems[3] = 30; elems[4] = 40; @@ -807,7 +806,7 @@ mod tests { /// the result offset/size dtypes preserve signedness (widened to >=32-bit for offsets). #[test] fn test_rebuild_preserves_signed_offset_and_size_types() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); use crate::arrays::listview::ListViewArraySlotsExt; use crate::dtype::PType; @@ -853,7 +852,7 @@ mod tests { /// Both offsets and sizes are u8, and offset + size exceeds u8::MAX. #[test] fn test_rebuild_trim_elements_sum_overflows_type() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_iter(vec![0i32; 261]).into_array(); let offsets = PrimitiveArray::from_iter(vec![215u8, 0]).into_array(); let sizes = PrimitiveArray::from_iter(vec![46u8, 10]).into_array(); diff --git a/vortex-array/src/arrays/listview/tests/basic.rs b/vortex-array/src/arrays/listview/tests/basic.rs index 729e1543c64..8b8c6e45345 100644 --- a/vortex-array/src/arrays/listview/tests/basic.rs +++ b/vortex-array/src/arrays/listview/tests/basic.rs @@ -2,14 +2,15 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::ListArray; @@ -24,9 +25,11 @@ use crate::dtype::PType; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_basic_listview_comprehensive() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Comprehensive test for basic ListView functionality including scalar_at. // Logical lists: [[1,2,3], [4,5], [6,7,8,9]] let elements = buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9].into_array(); @@ -57,7 +60,7 @@ fn test_basic_listview_comprehensive() { // Test scalar_at which returns entire lists as Scalar values. let first_scalar = listview - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!( first_scalar, @@ -83,7 +86,7 @@ fn test_basic_listview_comprehensive() { #[test] fn test_out_of_order_offsets() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // ListView-specific: Tests that offsets can be non-sequential and out-of-order. // Logical lists: [[7,8,9], [1,2,3], [4,5,6]] let elements = buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9].into_array(); @@ -134,7 +137,7 @@ fn test_empty_listview() { #[test] fn test_from_list_array() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test conversion from ListArray to ListViewArray. // Logical lists: [[1,2], null, [5,6,7]] let offsets = buffer![0i64, 2, 4, 7].into_array(); @@ -142,7 +145,7 @@ fn test_from_list_array() -> VortexResult<()> { let validity = Validity::from_iter([true, false, true]); let list_array = ListArray::try_new(elements, offsets, validity, &mut ctx)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list_view = list_view_from_list(list_array, &mut ctx)?; assert_eq!(list_view.len(), 3); @@ -155,9 +158,9 @@ fn test_from_list_array() -> VortexResult<()> { ); // Check validity is preserved. - assert!(list_view.is_valid(0, &mut array_session().create_execution_ctx())?); - assert!(list_view.is_invalid(1, &mut array_session().create_execution_ctx())?); - assert!(list_view.is_valid(2, &mut array_session().create_execution_ctx())?); + assert!(list_view.is_valid(0, &mut SESSION.create_execution_ctx())?); + assert!(list_view.is_invalid(1, &mut SESSION.create_execution_ctx())?); + assert!(list_view.is_valid(2, &mut SESSION.create_execution_ctx())?); // Check third list. assert_arrays_eq!( @@ -174,7 +177,7 @@ fn test_from_list_array() -> VortexResult<()> { #[case::constant_offsets(false, true)] // Varying sizes, constant offsets #[case::both_constant(true, true)] // Both constant fn test_listview_with_constant_arrays(#[case] const_sizes: bool, #[case] const_offsets: bool) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Logical lists vary by case: // - constant_sizes: [[1,2,3], [4,5,6], [7,8,9]] (size 3 each, varying offsets) // - constant_offsets: [[1,2,3], [1,2], [1]] (all start at 0, varying sizes) @@ -251,7 +254,7 @@ fn test_validation_errors( offsets.into_array(), sizes.into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); assert!(result.is_err()); @@ -260,7 +263,7 @@ fn test_validation_errors( #[test] fn test_validate_nullable_offsets() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Logical lists (invalid due to nullable offsets): [[1,2], [3], ???] let elements = buffer![1i32, 2, 3, 4, 5].into_array(); let offsets = PrimitiveArray::from_option_iter(vec![Some(0u32), Some(2), None]).into_array(); @@ -279,7 +282,7 @@ fn test_validate_nullable_offsets() { #[test] fn test_validate_nullable_sizes() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Logical lists (invalid due to nullable sizes): [[1,2], ???, [2,3]] let elements = buffer![1i32, 2, 3, 4, 5].into_array(); let offsets = buffer![0u32, 2, 1].into_array(); @@ -298,7 +301,7 @@ fn test_validate_nullable_sizes() { #[test] fn test_validate_offset_plus_size_overflow() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Logical lists (invalid due to overflow): would overflow, [[1], [1]] let elements = buffer![1i32, 2, 3, 4, 5].into_array(); // Create an offset + size that would overflow. @@ -317,7 +320,7 @@ fn test_validate_offset_plus_size_overflow() { #[test] fn test_validate_invalid_validity_length() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Logical lists (invalid due to validity length mismatch): [[1,2], [3,4], [5]] let elements = buffer![1i32, 2, 3, 4, 5].into_array(); let offsets = buffer![0u32, 2, 4].into_array(); @@ -337,7 +340,7 @@ fn test_validate_invalid_validity_length() { #[test] fn test_validate_non_integer_offsets() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Logical lists (invalid due to float offsets): [[1,2], [3,4], [5]] let elements = buffer![1i32, 2, 3, 4, 5].into_array(); // Try to use float offsets. @@ -356,7 +359,7 @@ fn test_validate_non_integer_offsets() { #[test] fn test_validate_different_int_types() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test that different integer types work as long as sizes type ≤ offsets type. // Logical lists: [[1,2], [3], [2,3]] let elements = buffer![1i32, 2, 3, 4, 5].into_array(); @@ -368,7 +371,7 @@ fn test_validate_different_int_types() { #[test] fn test_validate_u64_overflow() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test overflow with u64 offsets and sizes. // Logical lists (invalid due to u64 overflow): would overflow, [[0], [0]] let elements = PrimitiveArray::from_iter(0i32..100).into_array(); @@ -387,7 +390,7 @@ fn test_validate_u64_overflow() { #[test] fn test_verify_is_zero_copy_to_list() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create a ListView that IS zero-copyable to List. // Logical lists: [[1,2], [3,4], [5]] let elements = buffer![1i32, 2, 3, 4, 5].into_array(); @@ -405,7 +408,7 @@ fn test_verify_is_zero_copy_to_list() { #[test] #[should_panic(expected = "Zero-copy-to-list requires views to be non-overlapping and ordered")] fn test_verify_is_zero_copy_to_list_overlapping() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create a ListView that is NOT zero-copyable to List due to overlapping views. // Logical lists: [[1,2], [2,3,4], [3,4]] let elements = buffer![1i32, 2, 3, 4, 5].into_array(); @@ -423,7 +426,7 @@ fn test_verify_is_zero_copy_to_list_overlapping() { #[test] #[should_panic(expected = "Zero-copy-to-list requires views to be non-overlapping and ordered")] fn test_validate_monotonic_ends_with_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Regression test for issue #5412 // Tests that validate_zctl catches incorrect NULL offsets @@ -452,7 +455,7 @@ fn test_validate_monotonic_ends_with_nulls() { #[test] fn test_validate_monotonic_ends_correct_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test that correctly placed NULLs pass validation // Elements: [1, 2, 3, 4] // View 0: [1, 2] at offset 0 diff --git a/vortex-array/src/arrays/listview/tests/common.rs b/vortex-array/src/arrays/listview/tests/common.rs index 98e7d8b7c05..0f643ece100 100644 --- a/vortex-array/src/arrays/listview/tests/common.rs +++ b/vortex-array/src/arrays/listview/tests/common.rs @@ -17,7 +17,7 @@ use crate::validity::Validity; /// A shared session for `ListView` tests, used to create execution contexts via /// [`create_execution_ctx`](crate::VortexSessionExecute::create_execution_ctx). -pub static SESSION: LazyLock = LazyLock::new(crate::array_session); +pub static SESSION: LazyLock = LazyLock::new(VortexSession::empty); /// Creates a basic ListView for testing: [[0,1,2], [3,4], [5,6], [7,8,9]] pub fn create_basic_listview() -> ListViewArray { diff --git a/vortex-array/src/arrays/listview/tests/density.rs b/vortex-array/src/arrays/listview/tests/density.rs index 732c025b922..12d21890be0 100644 --- a/vortex-array/src/arrays/listview/tests/density.rs +++ b/vortex-array/src/arrays/listview/tests/density.rs @@ -4,9 +4,12 @@ //! Tests for `compute_referenced_elements_mask`, `compute_density`, and //! `estimate_density` on `ListViewArray`. +use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_mask::Mask; +use vortex_session::VortexSession; use super::common::create_basic_listview; use super::common::create_empty_lists_listview; @@ -25,11 +28,12 @@ use crate::expr::stats::Stat; use crate::scalar::ScalarValue; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + const EPS: f32 = 1e-6; fn test_execution_ctx() -> ExecutionCtx { - let session = crate::array_session(); - session.create_execution_ctx() + SESSION.create_execution_ctx() } #[test] diff --git a/vortex-array/src/arrays/listview/tests/filter.rs b/vortex-array/src/arrays/listview/tests/filter.rs index bd2df734c70..8a0e6e5b679 100644 --- a/vortex-array/src/arrays/listview/tests/filter.rs +++ b/vortex-array/src/arrays/listview/tests/filter.rs @@ -24,7 +24,7 @@ use crate::assert_arrays_eq; use crate::compute::conformance::filter::test_filter_conformance; use crate::validity::Validity; -static SESSION: LazyLock = LazyLock::new(crate::array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); // Conformance tests for common filter scenarios. #[rstest] diff --git a/vortex-array/src/arrays/listview/tests/nested.rs b/vortex-array/src/arrays/listview/tests/nested.rs index 6a1a075b604..c3f1c5a53b9 100644 --- a/vortex-array/src/arrays/listview/tests/nested.rs +++ b/vortex-array/src/arrays/listview/tests/nested.rs @@ -1,11 +1,13 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use vortex_buffer::buffer; +use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::ListView; use crate::arrays::ListViewArray; use crate::arrays::PrimitiveArray; @@ -19,13 +21,15 @@ use crate::dtype::PType; use crate::dtype::StructFields; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + //////////////////////////////////////////////////////////////////////////////////////////////////// // ListView of ListView with overlapping data //////////////////////////////////////////////////////////////////////////////////////////////////// #[test] fn test_listview_of_listview_with_overlapping() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create elements that will be shared between inner lists. // Elements: [1, 2, 3, 4, 5, 6, 7, 8] let elements = buffer![1i32, 2, 3, 4, 5, 6, 7, 8].into_array(); @@ -81,7 +85,7 @@ fn test_listview_of_listview_with_overlapping() { // inner[0] should be [1, 2, 3]. assert_eq!( inner0 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .as_primitive() .as_::() @@ -90,7 +94,7 @@ fn test_listview_of_listview_with_overlapping() { ); assert_eq!( inner0 - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() .as_primitive() .as_::() @@ -101,7 +105,7 @@ fn test_listview_of_listview_with_overlapping() { // inner[1] should be [3, 4, 5] - shares element 3 with inner[0]. assert_eq!( inner1 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .as_primitive() .as_::() @@ -110,7 +114,7 @@ fn test_listview_of_listview_with_overlapping() { ); assert_eq!( inner1 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .as_primitive() .as_::() @@ -132,7 +136,7 @@ fn test_listview_of_listview_with_overlapping() { #[test] fn test_deeply_nested_out_of_order() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create 3-level nested ListView with out-of-order offsets at each level. let elements = buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16].into_array(); @@ -201,7 +205,7 @@ fn test_deeply_nested_out_of_order() { assert_arrays_eq!( inner, buffer![9i32, 10].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -211,7 +215,7 @@ fn test_deeply_nested_out_of_order() { #[test] fn test_mixed_offset_size_types() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test with u64 offsets and u8 sizes at outer level, // u32 offsets and u16 sizes at inner level. // This tests type conversion edge cases unique to ListView. @@ -266,7 +270,7 @@ fn test_mixed_offset_size_types() { .list_elements_at(0, &mut ctx) .unwrap(), PrimitiveArray::from_iter(30i32..37), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -276,7 +280,7 @@ fn test_mixed_offset_size_types() { #[test] fn test_listview_zero_and_overlapping() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Mix of empty lists, overlapping lists, and normal lists. let elements = buffer![1i32, 2, 3, 4, 5].into_array(); @@ -330,7 +334,7 @@ fn test_listview_zero_and_overlapping() { assert_eq!(inner1.len(), 3); // [1, 2, 3] assert_eq!( inner1 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .as_primitive() .as_::() @@ -349,7 +353,7 @@ fn test_listview_zero_and_overlapping() { assert_eq!(inner3.len(), 3); // [2, 3, 4] assert_eq!( inner3 - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .as_primitive() .as_::() @@ -368,7 +372,7 @@ fn test_listview_zero_and_overlapping() { #[test] fn test_listview_of_struct_with_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create structs with fields that could be null. let struct_fields = StructFields::new( FieldNames::from(["id", "value"].as_slice()), @@ -430,7 +434,7 @@ fn test_listview_of_struct_with_nulls() { // The middle element (struct[2]) should be null. assert!( list1 - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); diff --git a/vortex-array/src/arrays/listview/tests/nullability.rs b/vortex-array/src/arrays/listview/tests/nullability.rs index 05fa9958d3e..b9197d407c7 100644 --- a/vortex-array/src/arrays/listview/tests/nullability.rs +++ b/vortex-array/src/arrays/listview/tests/nullability.rs @@ -2,13 +2,14 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::buffer; +use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ListViewArray; use crate::arrays::PrimitiveArray; @@ -20,9 +21,11 @@ use crate::dtype::PType; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_nullable_listview_comprehensive() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Comprehensive test for nullable ListView including scalar_at with nulls. // Logical lists: [[1,2], null, [5,6]] let elements = buffer![1i32, 2, 3, 4, 5, 6].into_array(); @@ -40,17 +43,17 @@ fn test_nullable_listview_comprehensive() { // Check validity. assert!( listview - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); assert!( listview - .is_invalid(1, &mut array_session().create_execution_ctx()) + .is_invalid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); assert!( listview - .is_valid(2, &mut array_session().create_execution_ctx()) + .is_valid(2, &mut SESSION.create_execution_ctx()) .unwrap() ); @@ -62,7 +65,7 @@ fn test_nullable_listview_comprehensive() { // Test scalar_at with nulls. let first = listview - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!first.is_null()); assert_eq!( @@ -75,12 +78,12 @@ fn test_nullable_listview_comprehensive() { ); let second = listview - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(second.is_null()); let third = listview - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(!third.is_null()); assert_eq!( @@ -97,13 +100,13 @@ fn test_nullable_listview_comprehensive() { assert_eq!(null_list_data.len(), 2); assert_eq!( null_list_data - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 3i32.into() ); assert_eq!( null_list_data - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 4i32.into() ); @@ -125,7 +128,7 @@ fn test_nullable_patterns(#[case] validity: Validity, #[case] expected_validity: for (i, &expected) in expected_validity.iter().enumerate() { assert_eq!( listview - .is_valid(i, &mut array_session().create_execution_ctx()) + .is_valid(i, &mut SESSION.create_execution_ctx()) .unwrap(), expected ); @@ -134,7 +137,7 @@ fn test_nullable_patterns(#[case] validity: Validity, #[case] expected_validity: #[test] fn test_nullable_elements() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test with nullable elements inside the lists. // Logical lists: [[Some(1), None], [Some(3), None], [Some(5), Some(6)]] let elements = @@ -153,19 +156,19 @@ fn test_nullable_elements() { assert_eq!(first_list.len(), 2); assert!( !first_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert_eq!( first_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 1i32.into() ); assert!( first_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); @@ -174,19 +177,19 @@ fn test_nullable_elements() { let second_list = listview.list_elements_at(1, &mut ctx).unwrap(); assert!( !second_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert_eq!( second_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 3i32.into() ); assert!( second_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); @@ -195,25 +198,25 @@ fn test_nullable_elements() { let third_list = listview.list_elements_at(2, &mut ctx).unwrap(); assert!( !third_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert_eq!( third_list - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 5i32.into() ); assert!( !third_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert_eq!( third_list - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), 6i32.into() ); @@ -227,7 +230,7 @@ fn test_nullable_elements() { #[test] fn test_validity_length_mismatch() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Logical lists (invalid due to validity length mismatch): [[1,2], [3,4]] let elements = buffer![1i32, 2, 3, 4].into_array(); let offsets = buffer![0i32, 2].into_array(); diff --git a/vortex-array/src/arrays/listview/tests/operations.rs b/vortex-array/src/arrays/listview/tests/operations.rs index 28e83bf1ad6..45cace9c945 100644 --- a/vortex-array/src/arrays/listview/tests/operations.rs +++ b/vortex-array/src/arrays/listview/tests/operations.rs @@ -2,11 +2,13 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_mask::Mask; +use vortex_session::VortexSession; use super::common::create_basic_listview; use super::common::create_large_listview; @@ -15,7 +17,6 @@ use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; use crate::aggregate_fn::fns::is_constant::is_constant; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::ListView; @@ -31,13 +32,15 @@ use crate::dtype::Nullability; use crate::dtype::PType; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + //////////////////////////////////////////////////////////////////////////////////////////////////// // Slice tests //////////////////////////////////////////////////////////////////////////////////////////////////// #[test] fn test_slice_comprehensive() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Comprehensive test for basic slicing, full array, and single element cases. // Logical lists: [[1,2,3], [4,5], [6,7,8], [9,10]] let elements = buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10].into_array(); @@ -81,10 +84,10 @@ fn test_slice_comprehensive() { assert_eq!( full_list .array() - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), listview - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), "Mismatch at index {}", i @@ -109,7 +112,7 @@ fn test_slice_comprehensive() { #[test] fn test_slice_out_of_order() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // ListView-specific: Test slicing with out-of-order offsets. // Logical lists: [[70,80], [10,20,30], [40,50,60], [90], [30]] let elements = buffer![10i32, 20, 30, 40, 50, 60, 70, 80, 90].into_array(); @@ -179,7 +182,7 @@ fn test_slice_out_of_order() { #[test] fn test_slice_with_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test slicing with nullable ListView. // Logical lists: [[1,2], null, [5,6], null] let elements = buffer![1i32, 2, 3, 4, 5, 6, 7, 8].into_array(); @@ -202,13 +205,13 @@ fn test_slice_with_nulls() { assert!( sliced_list .array() - .is_invalid(0, &mut array_session().create_execution_ctx()) + .is_invalid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); // Original index 1 was null. assert!( sliced_list .array() - .is_valid(1, &mut array_session().create_execution_ctx()) + .is_valid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); // Original index 2 was valid. @@ -268,7 +271,7 @@ fn test_slice_edge_cases( #[case::f32_to_f64(PType::F32, PType::F64)] #[case::u8_to_u16(PType::U8, PType::U16)] fn test_cast_numeric_types(#[case] from_ptype: PType, #[case] to_ptype: PType) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = match from_ptype { PType::I32 => buffer![1i32, 2, 3, 4, 5, 6].into_array(), PType::F32 => buffer![1.0f32, 2.0, 3.0, 4.0].into_array(), @@ -304,7 +307,7 @@ fn test_cast_numeric_types(#[case] from_ptype: PType, #[case] to_ptype: PType) { assert_eq!(result.dtype(), &target_dtype); let result_list = result - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert!( result_list.len() == if from_ptype == PType::F32 { 2 } else { 3 }, @@ -342,16 +345,12 @@ fn test_cast_numeric_types(#[case] from_ptype: PType, #[case] to_ptype: PType) { Validity::NonNullable, &mut ctx, ); - assert_arrays_eq!( - result_list, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(result_list, expected, &mut SESSION.create_execution_ctx()); } #[test] fn test_cast_with_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Logical lists: [[10,20], null] let elements = buffer![10i32, 20, 30, 40].into_array(); let offsets = buffer![0u32, 2].into_array(); @@ -373,22 +372,22 @@ fn test_cast_with_nulls() { assert_eq!(result.dtype(), &target_dtype); let result_list = result - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert!( result_list - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); assert!( result_list - .is_invalid(1, &mut array_session().create_execution_ctx()) + .is_invalid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_arrays_eq!( result_list.list_elements_at(0, &mut ctx).unwrap(), buffer![10i64, 20].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -396,7 +395,7 @@ fn test_cast_with_nulls() { #[case::empty_lists(vec![0, 1, 0, 1], 4)] #[case::overlapping(vec![3, 3, 5], 3)] fn test_cast_special_patterns(#[case] expected_sizes: Vec, #[case] list_count: usize) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let is_empty_case = list_count == 4; let (elements, offsets, sizes) = if is_empty_case { @@ -432,7 +431,7 @@ fn test_cast_special_patterns(#[case] expected_sizes: Vec, #[case] list_c let result = listview.cast(target_dtype).unwrap(); let result_list = result - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!(result_list.len(), list_count); @@ -463,16 +462,12 @@ fn test_cast_special_patterns(#[case] expected_sizes: Vec, #[case] list_c Validity::NonNullable, &mut ctx, ); - assert_arrays_eq!( - result_list, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(result_list, expected, &mut SESSION.create_execution_ctx()); } #[test] fn test_cast_large_dataset() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test with larger data. // Logical lists: [[0..4], [4..8], [8..12], ..., [76..80]] (20 lists of size 4) let elements = buffer![0u16..100].into_array(); @@ -495,7 +490,7 @@ fn test_cast_large_dataset() { let result = listview.cast(target_dtype).unwrap(); let result_list = result - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!(result_list.len(), 20); @@ -509,11 +504,7 @@ fn test_cast_large_dataset() { Validity::NonNullable, &mut ctx, ); - assert_arrays_eq!( - result_list, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(result_list, expected, &mut SESSION.create_execution_ctx()); } //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -522,7 +513,7 @@ fn test_cast_large_dataset() { #[test] fn test_zip_widens_false_element_nullability() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // [[1, 2], [3], [4]] let if_true = ListViewArray::new( buffer![1i32, 2, 3, 4].into_array(), @@ -546,7 +537,7 @@ fn test_zip_widens_false_element_nullability() -> VortexResult<()> { let result = mask .into_array() .zip(if_true, if_false)? - .execute::(&mut array_session().create_execution_ctx())?; + .execute::(&mut SESSION.create_execution_ctx())?; assert!(result.is::()); assert_eq!( result.dtype(), @@ -571,7 +562,7 @@ fn test_zip_widens_false_element_nullability() -> VortexResult<()> { #[test] fn test_zip_widens_true_element_nullability() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // [[1, null], [3], [4]] let if_true = ListViewArray::new( PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4)]).into_array(), @@ -595,7 +586,7 @@ fn test_zip_widens_true_element_nullability() -> VortexResult<()> { let result = mask .into_array() .zip(if_true, if_false)? - .execute::(&mut array_session().create_execution_ctx())?; + .execute::(&mut SESSION.create_execution_ctx())?; assert!(result.is::()); assert_eq!( result.dtype(), @@ -671,11 +662,11 @@ fn test_is_constant_basic( offsets.into_array(), sizes.into_array(), validity, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(is_constant(&listview, &mut ctx).unwrap(), expected); } @@ -694,7 +685,7 @@ fn test_constant_with_constant_elements() { .into_array(); // All lists contain [42, 42] so should be constant. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(is_constant(&listview, &mut ctx).unwrap()); } @@ -718,7 +709,7 @@ fn test_constant_with_nulls() { .with_zero_copy_to_list(true) } .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(!is_constant(&listview_mixed, &mut ctx).unwrap()); // Case 2: All nulls - should be constant. @@ -728,13 +719,13 @@ fn test_constant_with_nulls() { .with_zero_copy_to_list(true) } .into_array(); - let mut ctx2 = array_session().create_execution_ctx(); + let mut ctx2 = SESSION.create_execution_ctx(); assert!(is_constant(&listview_all_null, &mut ctx2).unwrap()); } #[test] fn test_constant_repeated_same_lists() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test multiple lists that are identical (overlapping). // Logical lists: [[10,20,30], [10,20,30], [10,20,30], [10,20,30]] let elements = buffer![10i32, 20, 30].into_array(); @@ -745,7 +736,7 @@ fn test_constant_repeated_same_lists() { ListViewArray::new(elements, offsets, sizes, Validity::NonNullable, &mut ctx).into_array(); // All lists are [10, 20, 30] so should be constant. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(is_constant(&listview, &mut ctx).unwrap()); } @@ -759,15 +750,12 @@ fn test_constant_repeated_same_lists() { #[case::nullable(create_nullable_listview())] #[case::large(create_large_listview())] fn test_mask_listview_conformance(#[case] listview: ListViewArray) { - test_mask_conformance( - &listview.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_mask_conformance(&listview.into_array(), &mut SESSION.create_execution_ctx()); } #[test] fn test_mask_preserves_structure() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // ListView-specific: Verify mask preserves offsets and sizes. // Logical lists: [[1,2], [3,4], [5,6], [7,8]] let elements = buffer![1i32, 2, 3, 4, 5, 6, 7, 8].into_array(); @@ -786,28 +774,28 @@ fn test_mask_preserves_structure() { assert_eq!(result.len(), 4); // Length is preserved. let result_list = result - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); // Check validity: true in selection means null. assert!( !result_list - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); // Masked. assert!( result_list - .is_valid(1, &mut array_session().create_execution_ctx()) + .is_valid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); // Not masked. assert!( !result_list - .is_valid(2, &mut array_session().create_execution_ctx()) + .is_valid(2, &mut SESSION.create_execution_ctx()) .unwrap() ); // Masked. assert!( !result_list - .is_valid(3, &mut array_session().create_execution_ctx()) + .is_valid(3, &mut SESSION.create_execution_ctx()) .unwrap() ); // Masked. @@ -841,30 +829,30 @@ fn test_mask_with_existing_nulls() { let selection = Mask::from_iter([false, false, true]); let result = listview.mask((!&selection).into_array()).unwrap(); let result_list = result - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); // Check combined validity: assert!( result_list - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); // Was valid, mask is false -> valid. assert!( !result_list - .is_valid(1, &mut array_session().create_execution_ctx()) + .is_valid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); // Existing null survives even where the mask retains the row. assert!( !result_list - .is_valid(2, &mut array_session().create_execution_ctx()) + .is_valid(2, &mut SESSION.create_execution_ctx()) .unwrap() ); // Was valid, mask is true -> invalid. } #[test] fn test_mask_with_gaps() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // ListView-specific: Mask with gaps in elements. // Logical lists: [[1,2], [5,6], [9,10]] (999 values are gaps) let elements = buffer![1i32, 2, 999, 999, 5, 6, 999, 999, 9, 10].into_array(); @@ -877,23 +865,23 @@ fn test_mask_with_gaps() { let selection = Mask::from_iter([true, false, false]); let result = listview.mask((!&selection).into_array()).unwrap(); let result_list = result - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!(result_list.len(), 3); assert!( !result_list - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); // Masked assert!( result_list - .is_valid(1, &mut array_session().create_execution_ctx()) + .is_valid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); // Not masked assert!( result_list - .is_valid(2, &mut array_session().create_execution_ctx()) + .is_valid(2, &mut SESSION.create_execution_ctx()) .unwrap() ); // Not masked @@ -904,7 +892,7 @@ fn test_mask_with_gaps() { #[test] fn test_mask_constant_arrays() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // ListView-specific: Test mask with ConstantArray offsets/sizes. // Logical lists: [[200,300], [200,300], [200,300]] let elements = buffer![100i32, 200, 300, 400, 500, 600].into_array(); @@ -925,23 +913,23 @@ fn test_mask_constant_arrays() { let selection = Mask::from_iter([false, true, false]); let result = const_list.mask((!&selection).into_array()).unwrap(); let result_list = result - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!(result_list.len(), 3); assert!( result_list - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); assert!( !result_list - .is_valid(1, &mut array_session().create_execution_ctx()) + .is_valid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); // Masked assert!( result_list - .is_valid(2, &mut array_session().create_execution_ctx()) + .is_valid(2, &mut SESSION.create_execution_ctx()) .unwrap() ); diff --git a/vortex-array/src/arrays/listview/tests/take.rs b/vortex-array/src/arrays/listview/tests/take.rs index b1b7dae6f61..0b353415f16 100644 --- a/vortex-array/src/arrays/listview/tests/take.rs +++ b/vortex-array/src/arrays/listview/tests/take.rs @@ -23,7 +23,7 @@ use crate::assert_arrays_eq; use crate::compute::conformance::take::test_take_conformance; use crate::validity::Validity; -static SESSION: LazyLock = LazyLock::new(crate::array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); // Conformance tests for common take scenarios. #[rstest] diff --git a/vortex-array/src/arrays/map/tests.rs b/vortex-array/src/arrays/map/tests.rs index 7e0847603a8..f9f60ec624a 100644 --- a/vortex-array/src/arrays/map/tests.rs +++ b/vortex-array/src/arrays/map/tests.rs @@ -1,10 +1,13 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use vortex_buffer::ByteBufferMut; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_mask::Mask; +use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use crate::Array; @@ -14,7 +17,6 @@ use crate::ArrayVTable; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -43,6 +45,8 @@ use crate::serde::SerializedArray; use crate::session::ArraySessionExt; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn map_dtype() -> VortexResult { MapDType::try_new( DType::Primitive(PType::I32, Nullability::NonNullable), @@ -117,7 +121,7 @@ fn sample_array() -> VortexResult { #[test] fn constructs_map_with_listview_entries() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let MapDataParts { map_dtype, entries } = sample_array()?.into_data_parts(); let array = MapArray::try_new(map_dtype.clone(), entries)?; @@ -133,7 +137,7 @@ fn constructs_map_with_listview_entries() -> VortexResult<()> { &map_dtype.entries_dtype() ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( array.map_validity().execute_mask(array.len(), &mut ctx)?, Mask::from_iter([true, true, false]) @@ -144,7 +148,7 @@ fn constructs_map_with_listview_entries() -> VortexResult<()> { #[test] fn rejects_malformed_entry_storage() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let map_dtype = map_dtype()?; let offsets = PrimitiveArray::from_iter([0u64]).into_array(); let sizes = PrimitiveArray::from_iter([1u64]).into_array(); @@ -196,7 +200,7 @@ fn rejects_malformed_entry_storage() -> VortexResult<()> { #[test] fn scalar_access_preserves_null_and_empty_maps() -> VortexResult<()> { let array = sample_array()?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( array.execute_scalar(0, &mut ctx)?, @@ -267,7 +271,7 @@ fn scalar_access_preserves_variable_entry_counts_and_utf8_pairs() -> VortexResul builder.append_scalar(scalar)?; } let array = builder.finish_into_map(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(array.entry_count_at(0, &mut ctx), 2); assert_eq!(array.entry_count_at(1, &mut ctx), 1); @@ -296,7 +300,7 @@ fn slice_preserves_map_rows() -> VortexResult<()> { ], )?; let sliced = source.slice(0..2)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(sliced.is::()); assert_arrays_eq!(sliced, expected, &mut ctx); @@ -308,7 +312,7 @@ fn slice_preserves_map_rows() -> VortexResult<()> { fn filter_handles_all_none_and_mixed_maps() -> VortexResult<()> { let source = sample_array()?.into_array(); let map_dtype = map_dtype()?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let all = source.filter(Mask::from_iter([true, true, true]))?; assert!(all.is::()); @@ -369,7 +373,7 @@ fn filter_dropping_nonempty_middle_row_clears_zero_copy_flag() -> VortexResult<( ], )?; let mask = Mask::from_iter([true, false, true]); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let reduced = source.filter(mask.clone())?; assert!(reduced.is::()); @@ -404,7 +408,7 @@ fn filter_dropping_nonempty_middle_row_clears_zero_copy_flag() -> VortexResult<( fn take_supports_reordered_duplicate_and_nullable_indices() -> VortexResult<()> { let source = sample_array()?.into_array(); let map_dtype = map_dtype()?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let taken = source.take(PrimitiveArray::from_iter([2u64, 0, 0]).into_array())?; let expected_taken = map_array_from_rows( @@ -469,7 +473,7 @@ fn mask_combines_with_existing_map_validity() -> VortexResult<()> { None, ], )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(masked.is::()); assert_arrays_eq!(masked, expected, &mut ctx); @@ -530,7 +534,7 @@ fn cast_widens_map_key_value_and_outer_nullability() -> VortexResult<()> { Some(vec![]), ], )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(cast.is::()); assert_arrays_eq!(cast, expected, &mut ctx); @@ -565,7 +569,7 @@ fn cast_can_drop_but_not_create_sortedness_assertion() -> VortexResult<()> { None, ], )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(cast, expected, &mut ctx); let unsorted_map_dtype = MapDType::try_new( @@ -610,7 +614,7 @@ fn null_map_cast_cannot_create_sortedness_assertion() -> VortexResult<()> { let constant_cast = ConstantArray::new(scalar, 2) .into_array() .cast(sorted_dtype.clone())?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(constant_cast.execute::(&mut ctx).is_err()); let all_null = @@ -633,7 +637,7 @@ fn filter_preserves_duplicate_map_keys() -> VortexResult<()> { (key(2), value(Some("duplicate"))), ])], )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(filtered, expected, &mut ctx); @@ -649,7 +653,7 @@ fn builder_appends_existing_map_arrays() -> VortexResult<()> { 0, vortex_buffer::BufferAllocatorRef::static_ref(), ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); builder.append_map_array(source.as_view(), &mut ctx)?; builder.append_map_array(source.as_view(), &mut ctx)?; let array = builder.finish_into_map(); @@ -685,7 +689,7 @@ fn canonicalizes_empty_constant_and_chunked_maps() -> VortexResult<()> { assert!(empty.as_map().is_empty()); assert_eq!(empty.as_map().dtype(), &dtype); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let constant = ConstantArray::new(sample_scalar(dtype.clone())?, 2) .into_array() .execute::(&mut ctx)?; @@ -721,7 +725,7 @@ fn canonicalizes_empty_constant_and_chunked_maps() -> VortexResult<()> { #[test] fn serde_roundtrip_uses_registered_map_vtable() -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); assert!(session.arrays().registry().contains_key(&Map.id())); let array = sample_array()?.into_array(); diff --git a/vortex-array/src/arrays/masked/compute/filter.rs b/vortex-array/src/arrays/masked/compute/filter.rs index 9d0fdfe8b23..3482637b12f 100644 --- a/vortex-array/src/arrays/masked/compute/filter.rs +++ b/vortex-array/src/arrays/masked/compute/filter.rs @@ -31,42 +31,43 @@ impl FilterReduce for Masked { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::MaskedArray; use crate::arrays::PrimitiveArray; use crate::compute::conformance::filter::test_filter_conformance; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case( MaskedArray::try_new( PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]).into_array(), Validity::from_iter([true, true, false, true, false]), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] #[case( MaskedArray::try_new( PrimitiveArray::from_iter([10i32, 20, 30]).into_array(), Validity::AllValid, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] #[case( MaskedArray::try_new( PrimitiveArray::from_iter(0..100).into_array(), Validity::from_iter((0..100).map(|i| i % 3 != 0)), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] fn test_filter_masked_conformance(#[case] array: MaskedArray) { - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/masked/compute/mask.rs b/vortex-array/src/arrays/masked/compute/mask.rs index ed9d17039a1..0de2dea5cd9 100644 --- a/vortex-array/src/arrays/masked/compute/mask.rs +++ b/vortex-array/src/arrays/masked/compute/mask.rs @@ -26,42 +26,43 @@ impl MaskReduce for Masked { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::MaskedArray; use crate::arrays::PrimitiveArray; use crate::compute::conformance::mask::test_mask_conformance; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case( MaskedArray::try_new( PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]).into_array(), Validity::from_iter([true, true, false, true, false]), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] #[case( MaskedArray::try_new( PrimitiveArray::from_iter([10i32, 20, 30]).into_array(), Validity::AllValid, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] #[case( MaskedArray::try_new( PrimitiveArray::from_iter(0..100).into_array(), Validity::from_iter((0..100).map(|i| i % 3 != 0)), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] fn test_mask_masked_conformance(#[case] array: MaskedArray) { - test_mask_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_mask_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/masked/compute/take.rs b/vortex-array/src/arrays/masked/compute/take.rs index cf621aaa377..286f109628e 100644 --- a/vortex-array/src/arrays/masked/compute/take.rs +++ b/vortex-array/src/arrays/masked/compute/take.rs @@ -42,42 +42,43 @@ impl TakeReduce for Masked { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::MaskedArray; use crate::arrays::PrimitiveArray; use crate::compute::conformance::take::test_take_conformance; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case( MaskedArray::try_new( PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]).into_array(), Validity::from_iter([true, true, false, true, false]), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] #[case( MaskedArray::try_new( PrimitiveArray::from_iter([10i32, 20, 30]).into_array(), Validity::AllValid, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] #[case( MaskedArray::try_new( PrimitiveArray::from_iter(0..100).into_array(), Validity::from_iter((0..100).map(|i| i % 3 != 0)), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] fn test_take_masked_conformance(#[case] array: MaskedArray) { - test_take_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/masked/tests.rs b/vortex-array/src/arrays/masked/tests.rs index 84b68de372c..8bba59daebb 100644 --- a/vortex-array/src/arrays/masked/tests.rs +++ b/vortex-array/src/arrays/masked/tests.rs @@ -1,17 +1,19 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::BitBuffer; use vortex_buffer::Buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; +use vortex_session::VortexSession; use super::*; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ListViewArray; use crate::arrays::PrimitiveArray; @@ -21,9 +23,11 @@ use crate::dtype::Nullability; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_repeated_probe_preserves_masked_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = MaskedArray::try_new( PrimitiveArray::from_iter([1i32, 2, 3]).into_array(), Validity::from_iter([true, false, true]), @@ -49,7 +53,7 @@ fn test_repeated_probe_preserves_masked_nulls() -> VortexResult<()> { #[case(Validity::AllValid, Nullability::Nullable)] #[case(Validity::from_iter([true, false, true]), Nullability::Nullable)] fn test_dtype_nullability(#[case] validity: Validity, #[case] expected: Nullability) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let child = PrimitiveArray::from_iter([1i32, 2, 3]).into_array(); let array = MaskedArray::try_new(child, validity, &mut ctx).unwrap(); @@ -63,7 +67,7 @@ fn test_dtype_nullability(#[case] validity: Validity, #[case] expected: Nullabil fn test_dtype_nullability_with_nullable_child() -> VortexResult<()> { let child = PrimitiveArray::new(vortex_buffer::buffer![1i32, 2, 3], Validity::AllValid).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = MaskedArray::try_new(child, Validity::from_iter([true, false, true]), &mut ctx)?; assert_arrays_eq!( array, @@ -81,7 +85,7 @@ fn test_empty_child_with_array_validity() -> VortexResult<()> { let validity = Validity::Array(BoolArray::new(BitBuffer::new_set(0), Validity::NonNullable).into_array()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(child.all_valid(&mut ctx)?); assert!(child.all_invalid(&mut ctx)?); @@ -97,26 +101,26 @@ fn test_masked_child_with_validity() -> VortexResult<()> { let array = MaskedArray::try_new( child, Validity::from_iter([true, false, true, false, true]), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )?; assert_arrays_eq!( array, PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, Some(5)]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } #[test] fn test_masked_child_all_valid() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let child = PrimitiveArray::from_iter([10i32, 20, 30]).into_array(); let array = MaskedArray::try_new(child, Validity::AllValid, &mut ctx).unwrap(); assert_eq!(array.len(), 3); assert_eq!( array - .valid_count(&mut array_session().create_execution_ctx()) + .valid_count(&mut SESSION.create_execution_ctx()) .unwrap(), 3 ); @@ -133,7 +137,7 @@ fn test_masked_child_all_valid() { #[case(Validity::from_iter([false, false, false]))] #[case(Validity::from_iter([true, false, true, false]))] fn test_masked_child_preserves_length(#[case] validity: Validity) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let len = match &validity { Validity::Array(arr) => arr.len(), _ => 3, @@ -145,7 +149,7 @@ fn test_masked_child_preserves_length(#[case] validity: Validity) { assert_eq!(array.len(), len); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!( array .validity() @@ -157,7 +161,7 @@ fn test_masked_child_preserves_length(#[case] validity: Validity) { #[test] fn masked_listview_execute_preserves_zctl_true() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Masking only intersects validity, so the zero-copy-to-list survives // execution. let elements = PrimitiveArray::from_iter([1i32, 2, 3]).into_array(); @@ -175,7 +179,7 @@ fn masked_listview_execute_preserves_zctl_true() -> VortexResult<()> { )?; let canonical = masked .into_array() - .execute::(&mut array_session().create_execution_ctx())?; + .execute::(&mut SESSION.create_execution_ctx())?; assert!(canonical.into_listview().is_zero_copy_to_list()); Ok(()) } diff --git a/vortex-array/src/arrays/masked/vtable/mod.rs b/vortex-array/src/arrays/masked/vtable/mod.rs index dad75ed4cea..507223a94a0 100644 --- a/vortex-array/src/arrays/masked/vtable/mod.rs +++ b/vortex-array/src/arrays/masked/vtable/mod.rs @@ -211,16 +211,18 @@ impl VTable for Masked { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::ByteBufferMut; use vortex_error::VortexError; + use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use crate::ArrayContext; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Masked; use crate::arrays::MaskedArray; use crate::arrays::PrimitiveArray; @@ -230,26 +232,28 @@ mod tests { use crate::serde::SerializedArray; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case( MaskedArray::try_new( PrimitiveArray::from_iter([1i32, 2, 3]).into_array(), Validity::AllValid, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] #[case( MaskedArray::try_new( PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]).into_array(), Validity::from_iter([true, true, false, true, false]), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] #[case( MaskedArray::try_new( PrimitiveArray::from_iter(0..100).into_array(), Validity::from_iter((0..100).map(|i| i % 3 != 0)), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ).unwrap() )] fn test_serde_roundtrip(#[case] array: MaskedArray) { @@ -260,7 +264,7 @@ mod tests { let serialized = array .clone() .into_array() - .serialize(&ctx, &array_session(), &SerializeOptions::default()) + .serialize(&ctx, &VortexSession::empty(), &SerializeOptions::default()) .unwrap(); // Concat into a single buffer. @@ -276,12 +280,12 @@ mod tests { &dtype, len, &ReadContext::new(ctx.to_ids()), - &array_session(), + &VortexSession::empty(), ) .unwrap(); assert!(decoded.is::()); - assert_arrays_eq!(decoded, array, &mut array_session().create_execution_ctx()); + assert_arrays_eq!(decoded, array, &mut SESSION.create_execution_ctx()); } /// Regression test for issue #5989: execute_fast_path returns child with wrong dtype. @@ -291,7 +295,7 @@ mod tests { /// MaskedArray always has Nullable dtype. #[test] fn test_execute_with_all_valid_preserves_nullable_dtype() -> Result<(), VortexError> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create a MaskedArray with AllValid validity. // Child has NonNullable dtype, but MaskedArray's dtype is Nullable. @@ -302,7 +306,7 @@ mod tests { assert_eq!(array.dtype().nullability(), Nullability::Nullable); // Execute the array. This should produce a Canonical with Nullable dtype. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result: Canonical = array.into_array().execute(&mut ctx)?; assert_eq!( diff --git a/vortex-array/src/arrays/null/compute/cast.rs b/vortex-array/src/arrays/null/compute/cast.rs index c1058156127..be9da91131e 100644 --- a/vortex-array/src/arrays/null/compute/cast.rs +++ b/vortex-array/src/arrays/null/compute/cast.rs @@ -29,11 +29,13 @@ impl CastReduce for Null { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::NullArray; use crate::builtins::ArrayBuiltins; use crate::compute::conformance::cast::test_cast_conformance; @@ -41,6 +43,8 @@ mod tests { use crate::dtype::Nullability; use crate::dtype::PType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_cast_null_to_null() { let null_array = NullArray::new(5); @@ -68,7 +72,7 @@ mod tests { for i in 0..5 { assert!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); @@ -90,9 +94,6 @@ mod tests { #[case(NullArray::new(100))] #[case(NullArray::new(0))] fn test_cast_null_conformance(#[case] array: NullArray) { - test_cast_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_cast_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/null/compute/mod.rs b/vortex-array/src/arrays/null/compute/mod.rs index 73a23fe7a8d..7a9cf9bce99 100644 --- a/vortex-array/src/arrays/null/compute/mod.rs +++ b/vortex-array/src/arrays/null/compute/mod.rs @@ -10,13 +10,15 @@ mod take; #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::NullArray; use crate::compute::conformance::consistency::test_array_consistency; use crate::compute::conformance::filter::test_filter_conformance; @@ -24,13 +26,15 @@ mod test { use crate::compute::conformance::take::test_take_conformance; use crate::dtype::DType; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_slice_nulls() { let nulls = NullArray::new(10); let sliced = nulls .slice(0..4) .unwrap() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!(sliced.len(), 4); @@ -39,10 +43,7 @@ mod test { sliced_arr .validity() .unwrap() - .execute_mask( - sliced_arr.len(), - &mut array_session().create_execution_ctx() - ) + .execute_mask(sliced_arr.len(), &mut SESSION.create_execution_ctx()) .unwrap(), Mask::AllFalse(4) )); @@ -54,7 +55,7 @@ mod test { let taken = nulls .take(buffer![0u64, 2, 4, 6, 8].into_array()) .unwrap() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!(taken.len(), 5); @@ -63,7 +64,7 @@ mod test { taken_arr .validity() .unwrap() - .execute_mask(taken_arr.len(), &mut array_session().create_execution_ctx()) + .execute_mask(taken_arr.len(), &mut SESSION.create_execution_ctx()) .unwrap(), Mask::AllFalse(5) )); @@ -74,7 +75,7 @@ mod test { let nulls = NullArray::new(10); let scalar = nulls - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert!(scalar.is_null()); assert_eq!(scalar.dtype().clone(), DType::Null); @@ -84,15 +85,15 @@ mod test { fn test_filter_null_array() { test_filter_conformance( &NullArray::new(5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( &NullArray::new(1).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( &NullArray::new(10).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -100,7 +101,7 @@ mod test { fn test_mask_null_array() { test_mask_conformance( &NullArray::new(5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -108,15 +109,15 @@ mod test { fn test_take_null_array_conformance() { test_take_conformance( &NullArray::new(5).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_take_conformance( &NullArray::new(1).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_take_conformance( &NullArray::new(10).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -129,9 +130,6 @@ mod test { #[case::null_array_large(NullArray::new(1000))] #[case::null_array_empty(NullArray::new(0))] fn test_null_consistency(#[case] array: NullArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/null/mod.rs b/vortex-array/src/arrays/null/mod.rs index a4db271bf8a..6c0160c4e15 100644 --- a/vortex-array/src/arrays/null/mod.rs +++ b/vortex-array/src/arrays/null/mod.rs @@ -160,7 +160,8 @@ impl VTable for Null { /// ``` /// # fn main() -> vortex_error::VortexResult<()> { /// use vortex_array::arrays::NullArray; -/// use vortex_array::{IntoArray, VortexSessionExecute, array_session}; +/// use vortex_array::{IntoArray, VortexSessionExecute}; +/// use vortex_session::VortexSession; /// /// // Create a null array with 5 elements /// let array = NullArray::new(5); @@ -170,7 +171,7 @@ impl VTable for Null { /// assert_eq!(sliced.len(), 2); /// /// // All elements are null -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// let scalar = array.execute_scalar(0, &mut ctx).unwrap(); /// assert!(scalar.is_null()); /// # Ok(()) diff --git a/vortex-array/src/arrays/patched/compute/compare.rs b/vortex-array/src/arrays/patched/compute/compare.rs index 0587d82f57f..800783b11c5 100644 --- a/vortex-array/src/arrays/patched/compute/compare.rs +++ b/vortex-array/src/arrays/patched/compute/compare.rs @@ -159,13 +159,15 @@ impl ApplyPatches<'_, V> { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::Patched; @@ -177,9 +179,11 @@ mod tests { use crate::scalar_fn::fns::operators::CompareOperator; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_basic() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = PrimitiveArray::from_iter(0u32..512).into_array(); let patches = Patches::new( 512, @@ -191,7 +195,7 @@ mod tests { ) .unwrap(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = Patched::from_array_and_patches(lhs, &patches, &mut ctx) .unwrap() @@ -214,7 +218,7 @@ mod tests { #[test] fn test_with_offset() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = PrimitiveArray::from_iter(0u32..512).into_array(); let patches = Patches::new( 512, @@ -226,7 +230,7 @@ mod tests { ) .unwrap(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = Patched::from_array_and_patches(lhs, &patches, &mut ctx).unwrap(); // Slice the array so that the first patch should be skipped. @@ -249,7 +253,7 @@ mod tests { #[test] fn test_subnormal_f32() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Subnormal f32 values are smaller than f32::MIN_POSITIVE but greater than 0 let subnormal: f32 = f32::MIN_POSITIVE / 2.0; assert!(subnormal > 0.0 && subnormal < f32::MIN_POSITIVE); @@ -265,7 +269,7 @@ mod tests { &mut ctx, )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = Patched::from_array_and_patches(lhs, &patches, &mut ctx)? .into_array() .try_downcast::() @@ -289,7 +293,7 @@ mod tests { #[test] fn test_pos_neg_zero() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = PrimitiveArray::from_iter([-0.0f32; 10]).into_array(); let patches = Patches::new( @@ -301,7 +305,7 @@ mod tests { &mut ctx, )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = Patched::from_array_and_patches(lhs, &patches, &mut ctx)? .into_array() .try_downcast::() diff --git a/vortex-array/src/arrays/patched/compute/filter.rs b/vortex-array/src/arrays/patched/compute/filter.rs index 85705e9c710..e8621ff0eab 100644 --- a/vortex-array/src/arrays/patched/compute/filter.rs +++ b/vortex-array/src/arrays/patched/compute/filter.rs @@ -63,9 +63,12 @@ impl FilterReduce for Patched { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -75,10 +78,12 @@ mod tests { use crate::optimizer::ArrayOptimizer; use crate::patches::Patches; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_filter_noop() -> VortexResult<()> { // Filter that doesn't prune any chunks (all data fits in one chunk). - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = buffer![u16::MIN; 5].into_array(); let patched_indices = buffer![3u8, 4].into_array(); @@ -102,7 +107,7 @@ mod tests { #[test] fn test_filter_with_offset() -> VortexResult<()> { // Test filtering where offset > 0. - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = buffer![u16::MIN; 4096].into_array(); let patched_indices = buffer![5u16, 1030].into_array(); @@ -127,7 +132,7 @@ mod tests { #[test] fn test_filter_basic() -> VortexResult<()> { // Basic test: filter with mask that crosses boundaries. - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = buffer![u16::MIN; 4096].into_array(); let patched_indices = buffer![1024u16, 1025].into_array(); @@ -151,7 +156,7 @@ mod tests { #[test] fn test_filter_complex() -> VortexResult<()> { // Filter with mask that crosses boundaries, with patches offset. - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = buffer![u16::MIN; 4096].into_array(); let patched_indices = buffer![1024u16, 1025].into_array(); @@ -175,7 +180,7 @@ mod tests { #[test] fn test_filter_sliced() -> VortexResult<()> { // Test filter on a sliced PatchedArray to exercise codepath where offset > 0. - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create a larger array (6 chunks) so we can slice and still have room // for the filter to prune chunks. @@ -210,7 +215,7 @@ mod tests { fn test_filter_with_offset_nonuniform() -> VortexResult<()> { // Test filtering with offset > 0 using non-uniform base values. // This catches slice_chunks bugs where inner coordinates are miscalculated. - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Use non-uniform values so that incorrect slicing is detectable. let base_values: Vec = (0u16..4096).collect(); @@ -244,7 +249,7 @@ mod tests { fn test_filter_with_offset_last_chunk() -> VortexResult<()> { // Test filtering with offset > 0 where the mask touches the last chunk. // This ensures we don't accidentally slice past the end of the array or mask. - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create a 6-chunk array (6144 elements). let array = buffer![u16::MIN; 6144].into_array(); diff --git a/vortex-array/src/arrays/patched/compute/take.rs b/vortex-array/src/arrays/patched/compute/take.rs index 48725596ce2..f271c714b6b 100644 --- a/vortex-array/src/arrays/patched/compute/take.rs +++ b/vortex-array/src/arrays/patched/compute/take.rs @@ -130,6 +130,7 @@ fn take_map( #[cfg(test)] mod tests { use std::ops::Range; + use std::sync::LazyLock; use vortex_buffer::buffer; use vortex_error::VortexResult; @@ -138,19 +139,20 @@ mod tests { use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Patched; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; use crate::patches::Patches; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn make_patched_array( base: &[u16], patch_indices: &[u32], patch_values: &[u16], slice: Range, ) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::from_iter(base.iter().copied()).into_array(); let patches = Patches::new( base.len(), @@ -161,8 +163,7 @@ mod tests { &mut ctx, )?; - let session = VortexSession::empty(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); Patched::from_array_and_patches(values, &patches, &mut ctx)? .into_array() @@ -171,7 +172,7 @@ mod tests { #[test] fn test_take_basic() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Array with base values [0, 0, 0, 0, 0] patched at indices [1, 3] with values [10, 30] let array = make_patched_array(&[0; 5], &[1, 3], &[10, 30], 0..5)?; @@ -187,7 +188,7 @@ mod tests { #[test] fn test_take_sliced() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = make_patched_array(&[0; 10], &[1, 3], &[100, 200], 2..10)?; let indices = buffer![0u32, 1, 2, 3, 7].into_array(); @@ -201,7 +202,7 @@ mod tests { #[test] fn test_take_out_of_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Array with base values [0, 0, 0, 0, 0] patched at indices [1, 3] with values [10, 30] let array = make_patched_array(&[0; 5], &[1, 3], &[10, 30], 0..5)?; @@ -217,7 +218,7 @@ mod tests { #[test] fn test_take_duplicates() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Array with base values [0, 0, 0, 0, 0] patched at index [2] with value [99] let array = make_patched_array(&[0; 5], &[2], &[99], 0..5)?; @@ -233,7 +234,7 @@ mod tests { #[test] fn test_take_with_null_indices() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); use crate::arrays::BoolArray; use crate::validity::Validity; diff --git a/vortex-array/src/arrays/patched/vtable/mod.rs b/vortex-array/src/arrays/patched/vtable/mod.rs index c153e2b8c00..01c71d52997 100644 --- a/vortex-array/src/arrays/patched/vtable/mod.rs +++ b/vortex-array/src/arrays/patched/vtable/mod.rs @@ -347,11 +347,14 @@ fn apply_patches_primitive( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::ByteBufferMut; use vortex_buffer::buffer; use vortex_buffer::buffer_mut; use vortex_error::VortexResult; + use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use crate::Array; @@ -360,7 +363,6 @@ mod tests { use crate::ArraySlots; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Patched; use crate::arrays::PatchedArray; use crate::arrays::PrimitiveArray; @@ -377,9 +379,11 @@ mod tests { use crate::session::ArraySessionExt; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_execute() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = buffer![0u16; 1024].into_array(); let patches = Patches::new( 1024, @@ -391,8 +395,7 @@ mod tests { ) .unwrap(); - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = Patched::from_array_and_patches(values, &patches, &mut ctx) .unwrap() @@ -408,7 +411,7 @@ mod tests { #[test] fn test_execute_sliced() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = buffer![0u16; 1024].into_array(); let patches = Patches::new( 1024, @@ -420,8 +423,7 @@ mod tests { ) .unwrap(); - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = Patched::from_array_and_patches(values, &patches, &mut ctx) .unwrap() @@ -437,7 +439,7 @@ mod tests { #[test] fn test_append_to_builder_non_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::new(buffer![0u16; 1024], Validity::NonNullable).into_array(); let patches = Patches::new( 1024, @@ -449,8 +451,7 @@ mod tests { ) .unwrap(); - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = Patched::from_array_and_patches(values, &patches, &mut ctx) .unwrap() @@ -476,7 +477,7 @@ mod tests { #[test] fn test_append_to_builder_sliced() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::new(buffer![0u16; 1024], Validity::NonNullable).into_array(); let patches = Patches::new( 1024, @@ -488,8 +489,7 @@ mod tests { ) .unwrap(); - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = Patched::from_array_and_patches(values, &patches, &mut ctx) .unwrap() @@ -515,7 +515,7 @@ mod tests { #[test] fn test_append_to_builder_with_validity() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create inner array with nulls at indices 0 and 5. let validity = Validity::from_iter((0..10).map(|i| i != 0 && i != 5)); let values = PrimitiveArray::new(buffer![0u16; 10], validity).into_array(); @@ -531,8 +531,7 @@ mod tests { ) .unwrap(); - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = Patched::from_array_and_patches(values, &patches, &mut ctx) .unwrap() @@ -570,7 +569,7 @@ mod tests { patch_indices: &[u32], patch_values: &[u16], ) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values: Vec = inner.into_iter().collect(); let len = values.len(); let array = PrimitiveArray::from_iter(values).into_array(); @@ -580,8 +579,7 @@ mod tests { let patches = Patches::new(len, 0, indices, patch_vals, None, &mut ctx)?; - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); Patched::from_array_and_patches(array, &patches, &mut ctx) } @@ -603,7 +601,7 @@ mod tests { let dtype = array.dtype().clone(); let len = array.len(); - let session = array_session(); + let session = VortexSession::empty(); session.arrays().register(Patched); let ctx = ArrayContext::empty().with_allowed_ids( @@ -661,7 +659,7 @@ mod tests { assert_eq!(array_ref.len(), new_array.len()); assert_eq!(array_ref.dtype(), new_array.dtype()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_iter((0..1024).map(|i| match i { 1 => 10u16, @@ -701,7 +699,7 @@ mod tests { .into_array(); // Execute and verify the inner values changed (except at patch positions) - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Expected: all 5s except indices 1, 2, 3 which are patched to 10, 20, 30 let expected = PrimitiveArray::from_iter([5u16, 10, 20, 30, 5, 5, 5, 5, 5, 5]); diff --git a/vortex-array/src/arrays/patched/vtable/operations.rs b/vortex-array/src/arrays/patched/vtable/operations.rs index ae115cd8cba..af3a6d253d8 100644 --- a/vortex-array/src/arrays/patched/vtable/operations.rs +++ b/vortex-array/src/arrays/patched/vtable/operations.rs @@ -59,21 +59,24 @@ impl OperationsVTable for Patched { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Patched; use crate::dtype::Nullability; use crate::optimizer::ArrayOptimizer; use crate::patches::Patches; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_simple() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = buffer![0u16; 1024].into_array(); let patches = Patches::new( 1024, @@ -85,8 +88,7 @@ mod tests { ) .unwrap(); - let session = VortexSession::empty(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = Patched::from_array_and_patches(values, &patches, &mut ctx) .unwrap() @@ -94,25 +96,25 @@ mod tests { assert_eq!( array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::primitive(0u16, Nullability::NonNullable) ); assert_eq!( array - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::primitive(1u16, Nullability::NonNullable) ); assert_eq!( array - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::primitive(1u16, Nullability::NonNullable) ); assert_eq!( array - .execute_scalar(3, &mut array_session().create_execution_ctx()) + .execute_scalar(3, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::primitive(1u16, Nullability::NonNullable) ); @@ -120,7 +122,7 @@ mod tests { #[test] fn test_multi_chunk() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = buffer![0u16; 4096].into_array(); let patches = Patches::new( 4096, @@ -132,8 +134,7 @@ mod tests { ) .unwrap(); - let session = VortexSession::empty(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = Patched::from_array_and_patches(values, &patches, &mut ctx) .unwrap() @@ -141,7 +142,7 @@ mod tests { for index in 0..array.len() { let value = array - .execute_scalar(index, &mut array_session().create_execution_ctx()) + .execute_scalar(index, &mut SESSION.create_execution_ctx()) .unwrap(); if [1, 2, 3].contains(&index) { @@ -154,7 +155,7 @@ mod tests { #[test] fn test_multi_chunk_sliced() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = buffer![0u16; 4096].into_array(); let patches = Patches::new( 4096, @@ -166,8 +167,7 @@ mod tests { ) .unwrap(); - let session = VortexSession::empty(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = Patched::from_array_and_patches(values, &patches, &mut ctx) .unwrap() @@ -181,14 +181,14 @@ mod tests { assert_eq!( array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), 1u16.into() ); for index in 1..array.len() { assert_eq!( array - .execute_scalar(index, &mut array_session().create_execution_ctx()) + .execute_scalar(index, &mut SESSION.create_execution_ctx()) .unwrap(), 0u16.into() ); diff --git a/vortex-array/src/arrays/patched/vtable/slice.rs b/vortex-array/src/arrays/patched/vtable/slice.rs index 70f82decbe7..6c59f2b528c 100644 --- a/vortex-array/src/arrays/patched/vtable/slice.rs +++ b/vortex-array/src/arrays/patched/vtable/slice.rs @@ -57,32 +57,35 @@ impl SliceReduce for Patched { #[cfg(test)] mod tests { use std::ops::Range; + use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::BufferMut; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Patched; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; use crate::dtype::NativePType; use crate::patches::Patches; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_reduce() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = buffer![0u16; 512].into_array(); let patch_indices = buffer![1u32, 8, 30].into_array(); let patch_values = buffer![u16::MAX; 3].into_array(); let patches = Patches::new(512, 0, patch_indices, patch_values, None, &mut ctx)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patched_array = Patched::from_array_and_patches(values, &patches, &mut ctx)?; @@ -131,11 +134,11 @@ mod tests { patch_indices.into_array(), patch_values.into_array(), None, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .unwrap(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patched_array = Patched::from_array_and_patches(inner.into_array(), &patches, &mut ctx) .unwrap() @@ -148,7 +151,7 @@ mod tests { #[test] fn test_stacked_slices() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::from_iter(0u64..10_000).into_array(); let patched_indices = buffer![1u32, 2, 1024, 2048, 3072, 3088].into_array(); diff --git a/vortex-array/src/arrays/piecewise_sequence/tests.rs b/vortex-array/src/arrays/piecewise_sequence/tests.rs index 1814c3f508f..8715c439b5c 100644 --- a/vortex-array/src/arrays/piecewise_sequence/tests.rs +++ b/vortex-array/src/arrays/piecewise_sequence/tests.rs @@ -1,15 +1,17 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use num_traits::AsPrimitive; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::ArrayContext; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::DecimalArray; @@ -26,6 +28,8 @@ use crate::dtype::Nullability; use crate::serde::SerializeOptions; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn piecewise_indices( starts: impl IntoIterator, lengths: &[u64], @@ -62,7 +66,7 @@ fn materializes_piecewise_indices() -> VortexResult<()> { let array = PiecewiseSequenceArray::try_new(starts, lengths, multipliers, 9)?.into_array(); let expected = PrimitiveArray::from_iter([3u64, 4, 5, 15, 16, 17, 21, 22, 23]).into_array(); - assert_arrays_eq!(array, expected, &mut array_session().create_execution_ctx()); + assert_arrays_eq!(array, expected, &mut SESSION.create_execution_ctx()); Ok(()) } @@ -74,7 +78,7 @@ fn materializes_repeated_and_empty_ranges() -> VortexResult<()> { let array = PiecewiseSequenceArray::try_new(starts, lengths, multipliers, 4)?.into_array(); let expected = PrimitiveArray::from_iter([5u64, 6, 5, 6]).into_array(); - assert_arrays_eq!(array, expected, &mut array_session().create_execution_ctx()); + assert_arrays_eq!(array, expected, &mut SESSION.create_execution_ctx()); Ok(()) } @@ -86,7 +90,7 @@ fn materializes_multiplied_ranges() -> VortexResult<()> { let array = PiecewiseSequenceArray::try_new(starts, lengths, multipliers, 5)?.into_array(); let expected = PrimitiveArray::from_iter([3u64, 5, 7, 15, 19]).into_array(); - assert_arrays_eq!(array, expected, &mut array_session().create_execution_ctx()); + assert_arrays_eq!(array, expected, &mut SESSION.create_execution_ctx()); Ok(()) } @@ -98,7 +102,7 @@ fn supports_constant_lengths() -> VortexResult<()> { let array = PiecewiseSequenceArray::try_new(starts, lengths, multipliers, 6)?.into_array(); let expected = PrimitiveArray::from_iter([0u64, 1, 10, 11, 20, 21]).into_array(); - assert_arrays_eq!(array, expected, &mut array_session().create_execution_ctx()); + assert_arrays_eq!(array, expected, &mut SESSION.create_execution_ctx()); Ok(()) } @@ -108,7 +112,7 @@ fn scalar_at_maps_into_piece() -> VortexResult<()> { let lengths = buffer![3u64, 3, 3].into_array(); let multipliers = buffer![1u64, 1, 1].into_array(); let array = PiecewiseSequenceArray::try_new(starts, lengths, multipliers, 9)?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(array.execute_scalar(0, &mut ctx)?, 3u64.into()); assert_eq!(array.execute_scalar(4, &mut ctx)?, 16u64.into()); @@ -124,7 +128,7 @@ fn constructor_defers_range_value_validation() -> VortexResult<()> { let array = PiecewiseSequenceArray::try_new(starts, lengths, multipliers, 2)?.into_array(); let err = array - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap_err(); assert!( err.to_string() @@ -142,7 +146,7 @@ fn execution_checks_declared_length() -> VortexResult<()> { let array = PiecewiseSequenceArray::try_new(starts, lengths, multipliers, 3)?.into_array(); let err = array - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap_err(); assert!( err.to_string() @@ -165,7 +169,7 @@ fn serialization_is_not_supported() -> VortexResult<()> { let err = array .serialize( &ArrayContext::empty(), - &array_session(), + &SESSION, &SerializeOptions::default(), ) .unwrap_err(); @@ -185,7 +189,7 @@ fn primitive_take_consumes_piecewise_indices() -> VortexResult<()> { assert_arrays_eq!( taken, PrimitiveArray::from_iter([3i32, 4, 10, 11, 12]).into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -205,7 +209,7 @@ fn primitive_take_handles_non_unit_multiplier() -> VortexResult<()> { assert_arrays_eq!( taken, PrimitiveArray::from_iter([3i32, 5, 7]).into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -218,7 +222,7 @@ fn bool_take_consumes_piecewise_indices() -> VortexResult<()> { assert_arrays_eq!( taken, BoolArray::from_iter([false, true, false, false]).into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -232,7 +236,7 @@ fn decimal_take_consumes_piecewise_indices() -> VortexResult<()> { assert_arrays_eq!( taken, DecimalArray::from_iter([20i128, 30, 50], decimal_dtype).into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -253,7 +257,7 @@ fn varbinview_take_consumes_piecewise_indices() -> VortexResult<()> { DType::Utf8(Nullability::NonNullable) ) .into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -274,14 +278,14 @@ fn varbin_take_consumes_piecewise_indices() -> VortexResult<()> { DType::Utf8(Nullability::NonNullable) ) .into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } #[test] fn contiguous_take_consumers_support_constant_piecewise_lengths() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = piecewise_indices_constant_length([1, 3], 2)?; let primitive = PrimitiveArray::from_iter(0i32..10).into_array(); @@ -341,7 +345,7 @@ fn contiguous_take_consumers_support_constant_piecewise_lengths() -> VortexResul #[test] fn list_take_consumes_constant_piecewise_lengths() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( buffer![0i32, 1, 2, 3, 4, 5, 6].into_array(), buffer![0u32, 2, 5, 5, 7].into_array(), @@ -371,6 +375,6 @@ fn fixed_size_list_take_builds_piecewise_element_indices() -> VortexResult<()> { let expected_elements = PrimitiveArray::from_iter([3i32, 4, 5, 9, 10, 11]).into_array(); let expected = FixedSizeListArray::new(expected_elements, 3, Validity::NonNullable, 2).into_array(); - assert_arrays_eq!(taken, expected, &mut array_session().create_execution_ctx()); + assert_arrays_eq!(taken, expected, &mut SESSION.create_execution_ctx()); Ok(()) } diff --git a/vortex-array/src/arrays/primitive/array/cast.rs b/vortex-array/src/arrays/primitive/array/cast.rs index a84e88cd1da..6733c0e4ebd 100644 --- a/vortex-array/src/arrays/primitive/array/cast.rs +++ b/vortex-array/src/arrays/primitive/array/cast.rs @@ -53,7 +53,7 @@ mod tests { use crate::dtype::PType; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_downcast_all_invalid() { diff --git a/vortex-array/src/arrays/primitive/array/mod.rs b/vortex-array/src/arrays/primitive/array/mod.rs index 1a4825df313..417f4e184a6 100644 --- a/vortex-array/src/arrays/primitive/array/mod.rs +++ b/vortex-array/src/arrays/primitive/array/mod.rs @@ -71,7 +71,8 @@ pub struct PrimitiveSlots { /// ``` /// # fn main() -> vortex_error::VortexResult<()> { /// use vortex_array::arrays::PrimitiveArray; -/// use vortex_array::{VortexSessionExecute, array_session}; +/// use vortex_array::{VortexSessionExecute}; +/// use vortex_session::VortexSession; /// /// // Create from iterator using FromIterator impl /// let array: PrimitiveArray = [1i32, 2, 3, 4, 5].into_iter().collect(); @@ -80,7 +81,7 @@ pub struct PrimitiveSlots { /// let sliced = array.slice(1..3)?; /// /// // Access individual values -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// let value = sliced.execute_scalar(0, &mut ctx).unwrap(); /// assert_eq!(value, 2i32.into()); /// diff --git a/vortex-array/src/arrays/primitive/array/patch.rs b/vortex-array/src/arrays/primitive/array/patch.rs index 49fbeac05b9..91c8222c79e 100644 --- a/vortex-array/src/arrays/primitive/array/patch.rs +++ b/vortex-array/src/arrays/primitive/array/patch.rs @@ -132,14 +132,18 @@ pub fn patch_chunk( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; + use vortex_session::VortexSession; use super::*; use crate::VortexSessionExecute; - use crate::array_session; use crate::assert_arrays_eq; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Regression: patch_chunk must not OOB when chunk_offsets (chunk granularity) /// reference more patches than patches_indices (element granularity) contains. #[test] @@ -180,7 +184,7 @@ mod tests { #[test] fn patch_sliced() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = PrimitiveArray::new(buffer![2u32; 10], Validity::AllValid); let sliced = input.slice(2..8).unwrap(); assert_arrays_eq!( diff --git a/vortex-array/src/arrays/primitive/compute/cast.rs b/vortex-array/src/arrays/primitive/compute/cast.rs index 3eb19b4b6f9..c937d68d611 100644 --- a/vortex-array/src/arrays/primitive/compute/cast.rs +++ b/vortex-array/src/arrays/primitive/compute/cast.rs @@ -659,18 +659,20 @@ fn cached_values_fit_in(array: ArrayView<'_, Primitive>, target_dtype: &DType) - #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::BitBuffer; use vortex_buffer::buffer; use vortex_error::VortexError; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::DecimalArray; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; @@ -685,9 +687,11 @@ mod test { use crate::expr::stats::Stat; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn cast_u32_u8() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = buffer![0u32, 10, 200].into_array(); // cast from u32 to u8 @@ -750,7 +754,7 @@ mod test { #[test] fn cast_u32_f32() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = buffer![0u32, 10, 200].into_array(); let u8arr = arr.cast(PType::F32.into()).unwrap(); assert_arrays_eq!( @@ -762,7 +766,7 @@ mod test { #[test] fn cast_integer_to_decimal_rescales() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(5, 2); let casted = PrimitiveArray::from_iter([42i32, -7]) .into_array() @@ -780,7 +784,7 @@ mod test { #[test] fn cast_same_width_signed_integer_to_decimal_reuses_buffer() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let source = PrimitiveArray::from_iter([42i32, -7]); let source_ptr = source.as_slice::().as_ptr(); let casted = source @@ -808,7 +812,7 @@ mod test { #[test] fn cast_same_width_signed_integer_to_decimal_reuses_buffer_with_cached_bounds() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let source = PrimitiveArray::from_iter([42i32, -7]); let source_ptr = source.as_slice::().as_ptr(); let source = source.into_array(); @@ -837,7 +841,7 @@ mod test { #[test] fn cast_same_width_signed_integer_to_decimal_ignores_out_of_range_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let source = PrimitiveArray::new(buffer![i32::MAX, 42], Validity::from_iter([false, true])); let source_ptr = source.as_slice::().as_ptr(); let casted = source @@ -863,7 +867,7 @@ mod test { #[test] fn cast_same_width_signed_integer_to_decimal_checks_precision() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let casted = PrimitiveArray::from_iter([i32::MAX]) .into_array() .cast(DType::Decimal( @@ -878,7 +882,7 @@ mod test { #[test] fn cast_u64_to_decimal() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(20, 0); let casted = PrimitiveArray::from_iter([u64::MAX]) .into_array() @@ -896,7 +900,7 @@ mod test { #[test] fn cast_integer_to_decimal_reports_scale_up_overflow() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Decimal(DecimalDType::new(38, 20), Nullability::NonNullable); let casted = PrimitiveArray::from_iter([u64::MAX]) .into_array() @@ -913,7 +917,7 @@ mod test { #[test] fn cast_u8_to_negative_scale_decimal() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(2, -2); let casted = PrimitiveArray::from_iter([200u8]) .into_array() @@ -931,7 +935,7 @@ mod test { #[test] fn cast_u64_to_negative_scale_decimal() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(1, -19); let casted = PrimitiveArray::from_iter([10_000_000_000_000_000_000u64]) .into_array() @@ -949,7 +953,7 @@ mod test { #[test] fn cast_integer_to_i256_decimal() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(39, 2); let casted = PrimitiveArray::from_iter([42i64]) .into_array() @@ -967,7 +971,7 @@ mod test { #[test] fn cast_all_null_integer_to_decimal() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(39, 2); let casted = PrimitiveArray::new(buffer![i64::MAX, i64::MIN], Validity::AllInvalid) .into_array() @@ -985,7 +989,7 @@ mod test { #[test] fn cast_integer_to_negative_scale_decimal_requires_exact_rescale() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(3, -2); let casted = PrimitiveArray::from_iter([1_200i32, -500]) .into_array() @@ -1009,7 +1013,7 @@ mod test { #[test] fn cast_zero_to_large_negative_scale_decimal() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(3, -128); let casted = PrimitiveArray::from_iter([0i32]) .into_array() @@ -1026,7 +1030,7 @@ mod test { #[test] fn cast_integer_to_decimal_ignores_out_of_range_null_lanes() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal_dtype = DecimalDType::new(3, 1); let casted = PrimitiveArray::new(buffer![999i32, 42], Validity::from_iter([false, true])) .into_array() @@ -1047,7 +1051,7 @@ mod test { #[test] fn cast_integer_to_decimal_checks_precision() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let casted = PrimitiveArray::from_iter([100i32]) .into_array() .cast(DType::Decimal( @@ -1062,7 +1066,7 @@ mod test { #[test] fn cast_floating_primitive_to_decimal_fails() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let casted = PrimitiveArray::from_iter([1.0f64]) .into_array() .cast(DType::Decimal( @@ -1085,7 +1089,7 @@ mod test { let error = arr .cast(PType::U32.into()) .and_then(|a| { - a.execute::(&mut array_session().create_execution_ctx()) + a.execute::(&mut SESSION.create_execution_ctx()) .map(|c| c.into_array()) }) .unwrap_err(); @@ -1100,7 +1104,7 @@ mod test { .into_array() .cast(PType::I32.into()) .and_then(|a| { - a.execute::(&mut array_session().create_execution_ctx()) + a.execute::(&mut SESSION.create_execution_ctx()) .map(|c| c.into_array()) }) .unwrap_err(); @@ -1114,7 +1118,7 @@ mod test { #[test] fn cast_with_invalid_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::new( buffer![-1i32, 0, 10], Validity::from_iter([false, true, true]), @@ -1131,7 +1135,7 @@ mod test { assert_eq!( p.validity() .unwrap() - .execute_mask(p.len(), &mut array_session().create_execution_ctx()) + .execute_mask(p.len(), &mut SESSION.create_execution_ctx()) .unwrap(), Mask::from(BitBuffer::from(vec![false, true, true])) ); @@ -1141,7 +1145,7 @@ mod test { /// buffer without allocation (pointer identity). #[test] fn cast_same_width_int_reinterprets_buffer() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let src = PrimitiveArray::from_iter([0u32, 10, 100]); let src_ptr = src.as_slice::().as_ptr(); @@ -1165,7 +1169,7 @@ mod test { let err = arr .cast(PType::I32.into()) .and_then(|a| { - a.execute::(&mut array_session().create_execution_ctx()) + a.execute::(&mut SESSION.create_execution_ctx()) .map(|c| c.into_array()) }) .unwrap_err(); @@ -1176,7 +1180,7 @@ mod test { /// touching the buffer contents. #[test] fn cast_same_width_all_null() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::new(buffer![0xFFu8, 0xFF], Validity::AllInvalid); let casted = arr .into_array() @@ -1195,7 +1199,7 @@ mod test { /// not prevent the cast from succeeding. #[test] fn cast_same_width_int_nullable_with_out_of_range_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // The null position holds u32::MAX which doesn't fit in i32, but it's // masked as invalid so the cast should still succeed via reinterpret. let arr = PrimitiveArray::new( @@ -1215,7 +1219,7 @@ mod test { #[test] fn cast_u32_to_u8_with_out_of_range_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::new( buffer![1000u32, 10u32, 42u32], Validity::from_iter([false, true, true]), @@ -1248,6 +1252,6 @@ mod test { #[case(PrimitiveArray::from_option_iter([Some(1i32), None, Some(-100), Some(0), None]).into_array())] #[case(buffer![42u32].into_array())] fn test_cast_primitive_conformance(#[case] array: ArrayRef) { - test_cast_conformance(&array, &mut array_session().create_execution_ctx()); + test_cast_conformance(&array, &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/primitive/compute/fill_null.rs b/vortex-array/src/arrays/primitive/compute/fill_null.rs index 2070584bf36..ea657448327 100644 --- a/vortex-array/src/arrays/primitive/compute/fill_null.rs +++ b/vortex-array/src/arrays/primitive/compute/fill_null.rs @@ -48,11 +48,13 @@ impl FillNullKernel for Primitive { #[cfg(test)] mod test { + use std::sync::LazyLock; + use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::primitive::compute::fill_null::BoolArray; use crate::assert_arrays_eq; @@ -60,9 +62,11 @@ mod test { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn fill_null_leading_none() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::from_option_iter([None, Some(8u8), None, Some(10), None]); let p = arr.into_array().fill_null(Scalar::from(42u8)).unwrap(); assert_arrays_eq!( @@ -73,7 +77,7 @@ mod test { assert!( p.validity() .unwrap() - .execute_mask(p.len(), &mut array_session().create_execution_ctx()) + .execute_mask(p.len(), &mut SESSION.create_execution_ctx()) .unwrap() .all_true() ); @@ -81,7 +85,7 @@ mod test { #[test] fn fill_null_all_none() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::from_option_iter([Option::::None, None, None, None, None]); let p = arr.into_array().fill_null(Scalar::from(255u8)).unwrap(); @@ -93,7 +97,7 @@ mod test { assert!( p.validity() .unwrap() - .execute_mask(p.len(), &mut array_session().create_execution_ctx()) + .execute_mask(p.len(), &mut SESSION.create_execution_ctx()) .unwrap() .all_true() ); @@ -101,7 +105,7 @@ mod test { #[test] fn fill_null_nullable_non_null() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = PrimitiveArray::new( buffer![8u8, 10, 12, 14, 16], Validity::Array(BoolArray::from_iter([true, true, true, true, true]).into_array()), @@ -115,7 +119,7 @@ mod test { assert!( p.validity() .unwrap() - .execute_mask(p.len(), &mut array_session().create_execution_ctx()) + .execute_mask(p.len(), &mut SESSION.create_execution_ctx()) .unwrap() .all_true() ); @@ -123,7 +127,7 @@ mod test { #[test] fn fill_null_non_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = buffer![8u8, 10, 12, 14, 16].into_array(); let p = arr.fill_null(Scalar::from(255u8)).unwrap(); assert_arrays_eq!( @@ -134,7 +138,7 @@ mod test { assert!( p.validity() .unwrap() - .execute_mask(p.len(), &mut array_session().create_execution_ctx()) + .execute_mask(p.len(), &mut SESSION.create_execution_ctx()) .unwrap() .all_true() ); diff --git a/vortex-array/src/arrays/primitive/compute/mask.rs b/vortex-array/src/arrays/primitive/compute/mask.rs index 8fb7d51e1b7..4cd307f0909 100644 --- a/vortex-array/src/arrays/primitive/compute/mask.rs +++ b/vortex-array/src/arrays/primitive/compute/mask.rs @@ -29,14 +29,18 @@ impl MaskReduce for Primitive { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::compute::conformance::mask::test_mask_conformance; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]))] #[case(PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), None]))] @@ -46,9 +50,6 @@ mod test { #[case(PrimitiveArray::from_iter([0.1f32, 0.2, 0.3, 0.4, 0.5]))] #[case(PrimitiveArray::from_option_iter([Some(1.1f64), None, Some(2.2), Some(3.3), None]))] fn test_mask_primitive_conformance(#[case] array: PrimitiveArray) { - test_mask_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_mask_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/primitive/compute/mod.rs b/vortex-array/src/arrays/primitive/compute/mod.rs index 382b42ee6e2..c12771d3da1 100644 --- a/vortex-array/src/arrays/primitive/compute/mod.rs +++ b/vortex-array/src/arrays/primitive/compute/mod.rs @@ -12,15 +12,19 @@ mod zip; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::compute::conformance::binary_numeric::test_binary_numeric_array; use crate::compute::conformance::consistency::test_array_consistency; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] // Basic primitive arrays #[case::i32(PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]))] @@ -39,10 +43,7 @@ mod tests { #[case::i16_negative(PrimitiveArray::from_iter([-100i16, -50, 0, 50, 100]))] #[case::f64_special(PrimitiveArray::from_iter([0.0f64, 1.0, -1.0, f64::INFINITY, f64::NEG_INFINITY]))] fn test_primitive_consistency(#[case] array: PrimitiveArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[rstest] @@ -52,9 +53,6 @@ mod tests { #[case::f32(PrimitiveArray::from_iter([1.5f32, 2.5, 3.5, 4.5, 5.5]))] #[case::f64(PrimitiveArray::from_iter([10.1f64, 20.2, 30.3, 40.4, 50.5]))] fn test_primitive_binary_numeric(#[case] array: PrimitiveArray) { - test_binary_numeric_array( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/primitive/compute/zip.rs b/vortex-array/src/arrays/primitive/compute/zip.rs index cd48bcddbc6..a653f01099e 100644 --- a/vortex-array/src/arrays/primitive/compute/zip.rs +++ b/vortex-array/src/arrays/primitive/compute/zip.rs @@ -148,18 +148,22 @@ mod tests { reason = "test fixtures use small indices that fit the target widths" )] + use std::sync::LazyLock; + use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Primitive; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; use crate::builtins::ArrayBuiltins; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// The branchless kernel must agree with the scalar reference across the chunk boundary (index /// 63/64) and the trailing remainder, for non-nullable inputs. #[test] @@ -171,7 +175,7 @@ mod tests { let bits: Vec = (0..len).map(|i| i.is_multiple_of(3) || i == 64).collect(); let mask = Mask::from_iter(bits.iter().copied()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mask .into_array() .zip(if_true, if_false)? @@ -202,7 +206,7 @@ mod tests { let bits: Vec = (0..len).map(|i| i.is_multiple_of(2)).collect(); let mask = Mask::from_iter(bits.iter().copied()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mask .into_array() .zip(if_true, if_false)? diff --git a/vortex-array/src/arrays/primitive/tests.rs b/vortex-array/src/arrays/primitive/tests.rs index 15569b2cebb..be192ffbe61 100644 --- a/vortex-array/src/arrays/primitive/tests.rs +++ b/vortex-array/src/arrays/primitive/tests.rs @@ -9,7 +9,6 @@ use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::PrimitiveArray; use crate::compute::conformance::filter::test_filter_conformance; @@ -23,7 +22,7 @@ use crate::search_sorted::SearchSortedPrimitiveArray; use crate::search_sorted::SearchSortedSide; use crate::validity::Validity; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[apply(search_sorted_conformance)] fn test_search_sorted_primitive( @@ -42,15 +41,15 @@ fn test_search_sorted_primitive( fn test_mask_primitive_array() { test_mask_conformance( &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::NonNullable).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_mask_conformance( &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::AllValid).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_mask_conformance( &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::AllInvalid).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_mask_conformance( &PrimitiveArray::new( @@ -58,7 +57,7 @@ fn test_mask_primitive_array() { Validity::Array(BoolArray::from_iter([true, false, true, false, true]).into_array()), ) .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -67,25 +66,25 @@ fn test_filter_primitive_array() { // Test various sizes test_filter_conformance( &PrimitiveArray::new(buffer![42i32], Validity::NonNullable).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( &PrimitiveArray::new(buffer![0, 1], Validity::NonNullable).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::NonNullable).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( &PrimitiveArray::new(buffer![0, 1, 2, 3, 4, 5, 6, 7], Validity::NonNullable).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); // Test with validity test_filter_conformance( &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::AllValid).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_filter_conformance( &PrimitiveArray::new( @@ -95,6 +94,6 @@ fn test_filter_primitive_array() { ), ) .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } diff --git a/vortex-array/src/arrays/primitive/vtable/mod.rs b/vortex-array/src/arrays/primitive/vtable/mod.rs index d41678d4a18..df4006626a2 100644 --- a/vortex-array/src/arrays/primitive/vtable/mod.rs +++ b/vortex-array/src/arrays/primitive/vtable/mod.rs @@ -217,15 +217,17 @@ pub struct Primitive; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::ByteBufferMut; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use crate::ArrayContext; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; use crate::buffer::BufferHandle; @@ -233,9 +235,11 @@ mod tests { use crate::serde::SerializedArray; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_nullable_primitive_serde_roundtrip() { - let session = array_session(); + let session = VortexSession::empty(); let mut ctx = session.create_execution_ctx(); let array = PrimitiveArray::new( buffer![1i32, 2, 3, 4], @@ -265,8 +269,7 @@ mod tests { #[test] fn test_with_buffers_replaces_primitive_buffer_with_equivalent_contents() -> VortexResult<()> { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::from_iter([1i32, 2, 3, 4]).into_array(); let replacement = BufferHandle::new_host(buffer![1i32, 2, 3, 4].into_byte_buffer()); diff --git a/vortex-array/src/arrays/scalar_fn/rules.rs b/vortex-array/src/arrays/scalar_fn/rules.rs index 8e14734927d..5383a614bd6 100644 --- a/vortex-array/src/arrays/scalar_fn/rules.rs +++ b/vortex-array/src/arrays/scalar_fn/rules.rs @@ -137,17 +137,19 @@ impl ArrayParentReduceRule for ScalarFilterPushdownRule { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_err; use vortex_mask::Mask; + use vortex_session::VortexSession; use super::ScalarFilterPushdownRule; use crate::VortexSessionExecute; use crate::array::IntoArray; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::Constant; @@ -175,6 +177,8 @@ mod tests { use crate::scalar_fn::fns::operators::Operator; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(0, [14, 14, 14, 14, 14])] #[case(1, [7, 27, 47, 67, 87])] @@ -219,11 +223,7 @@ mod tests { } } let expected = PrimitiveArray::from_iter(expected); - assert_arrays_eq!( - result, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(result, expected, &mut SESSION.create_execution_ctx()); Ok(()) } @@ -246,7 +246,7 @@ mod tests { assert_arrays_eq!( result, ConstantArray::new(list, 2), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -274,14 +274,13 @@ mod tests { assert_arrays_eq!( result, BoolArray::from_iter([false]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } #[test] fn test_reduce_isnull() -> VortexResult<()> { - let session = array_session(); - let ctx = &mut session.create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); let validity = BoolArray::from_iter([true, false, true]).into_array(); assert_arrays_eq!( diff --git a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs index c61c9add2f6..943d7a2a041 100644 --- a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs +++ b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs @@ -67,8 +67,11 @@ impl OperationsVTable for ScalarFn { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::ArraySlots; @@ -76,7 +79,6 @@ mod tests { use crate::VortexSessionExecute; use crate::array::Array; use crate::array::ArrayParts; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; @@ -97,9 +99,11 @@ mod tests { use crate::scalar_fn::fns::operators::Operator; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_scalar_fn_add() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = buffer![1i32, 2, 3].into_array(); let rhs = buffer![10i32, 20, 30].into_array(); @@ -198,7 +202,7 @@ mod tests { assert_arrays_eq!( scalar_fn_array, ConstantArray::new(list, 3), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) @@ -231,7 +235,7 @@ mod tests { #[test] fn test_scalar_fn_mul() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = buffer![2i32, 3, 4].into_array(); let rhs = buffer![5i32, 6, 7].into_array(); @@ -246,7 +250,7 @@ mod tests { #[test] fn test_scalar_fn_with_nullable() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::AllValid).into_array(); let rhs = PrimitiveArray::new( buffer![10i32, 20, 30], @@ -269,7 +273,7 @@ mod tests { #[test] fn test_scalar_fn_comparison() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = buffer![1i32, 5, 3].into_array(); let rhs = buffer![2i32, 5, 1].into_array(); @@ -301,7 +305,7 @@ mod tests { #[test] fn scalar_fn_probe() -> VortexResult<()> { - let ctx = &mut array_session().create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); let array = scalar_nested_add()?; let mut probe = array.probe(); @@ -315,7 +319,7 @@ mod tests { #[test] fn scalar_fn_repeated_probe() -> VortexResult<()> { - let ctx = &mut array_session().create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); let array = scalar_nested_add()?; let mut probe = array.repeated_probe(); @@ -329,7 +333,7 @@ mod tests { #[test] fn scalar_fn_all_valid() -> VortexResult<()> { - let ctx = &mut array_session().create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); let array = scalar_nested_add()?; assert!(!array.all_valid(ctx)?); assert!(!array.all_invalid(ctx)?); diff --git a/vortex-array/src/arrays/slice/vtable.rs b/vortex-array/src/arrays/slice/vtable.rs index ef5cac4027c..3b2351a065c 100644 --- a/vortex-array/src/arrays/slice/vtable.rs +++ b/vortex-array/src/arrays/slice/vtable.rs @@ -209,18 +209,22 @@ impl Debug for SliceMetadata { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::SliceArray; use crate::assert_arrays_eq; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_slice_slice() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Slice(1..4, Slice(2..8, base)) combines to Slice(3..6, base) let arr = PrimitiveArray::from_iter(0i32..10).into_array(); let inner_slice = SliceArray::new(arr, 2..8).into_array(); diff --git a/vortex-array/src/arrays/struct_/array.rs b/vortex-array/src/arrays/struct_/array.rs index f7792372e2c..6d3052f1b25 100644 --- a/vortex-array/src/arrays/struct_/array.rs +++ b/vortex-array/src/arrays/struct_/array.rs @@ -64,7 +64,8 @@ pub struct StructSlots { /// use vortex_array::arrays::{StructArray, BoolArray}; /// use vortex_array::validity::Validity; /// use vortex_array::dtype::FieldNames; -/// use vortex_array::{IntoArray, VortexSessionExecute, array_session}; +/// use vortex_array::{IntoArray, VortexSessionExecute}; +/// use vortex_session::VortexSession; /// use vortex_buffer::buffer; /// /// // Create struct with all non-null fields but struct-level nulls @@ -78,7 +79,7 @@ pub struct StructSlots { /// 2, /// Validity::Array(BoolArray::from_iter([true, false]).into_array()), // row 1 is null /// ).unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// /// // Row 0 is valid - returns a struct scalar with field values /// let row0 = struct_array.execute_scalar(0, &mut ctx).unwrap(); @@ -99,7 +100,8 @@ pub struct StructSlots { /// use vortex_array::arrays::struct_::StructArrayExt; /// use vortex_array::validity::Validity; /// use vortex_array::dtype::FieldNames; -/// use vortex_array::{IntoArray, VortexSessionExecute, array_session}; +/// use vortex_array::{IntoArray, VortexSessionExecute}; +/// use vortex_session::VortexSession; /// use vortex_buffer::buffer; /// /// // Create struct with duplicate "data" field names @@ -115,7 +117,7 @@ pub struct StructSlots { /// /// // field_by_name returns the FIRST "data" field /// let first_data = struct_array.unmasked_field_by_name("data").unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// assert_eq!(first_data.execute_scalar(0, &mut ctx).unwrap(), 1i32.into()); /// ``` /// diff --git a/vortex-array/src/arrays/struct_/compute/cast.rs b/vortex-array/src/arrays/struct_/compute/cast.rs index 74739aefd75..e73ea26446b 100644 --- a/vortex-array/src/arrays/struct_/compute/cast.rs +++ b/vortex-array/src/arrays/struct_/compute/cast.rs @@ -156,7 +156,7 @@ mod tests { use crate::scalar_fn::fns::cast::Cast; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); fn null_struct_cast_execute_parent( child: &ArrayRef, diff --git a/vortex-array/src/arrays/struct_/compute/mod.rs b/vortex-array/src/arrays/struct_/compute/mod.rs index 205690a6f8a..1d528448ad3 100644 --- a/vortex-array/src/arrays/struct_/compute/mod.rs +++ b/vortex-array/src/arrays/struct_/compute/mod.rs @@ -10,18 +10,20 @@ mod zip; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use Nullability::NonNullable; use Nullability::Nullable; use rstest::rstest; use vortex_buffer::BitBuffer; use vortex_buffer::buffer; use vortex_error::VortexExpect; + use vortex_session::VortexSession; use crate::Canonical; use crate::IntoArray as _; use crate::VortexSessionExecute; use crate::aggregate_fn::fns::is_constant::is_constant; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::PrimitiveArray; use crate::arrays::StructArray; @@ -38,9 +40,11 @@ mod tests { use crate::dtype::StructFields; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn take_empty_struct() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let struct_arr = StructArray::try_new(FieldNames::empty(), vec![], 10, Validity::NonNullable).unwrap(); let indices = PrimitiveArray::from_option_iter([Some(1), None]); @@ -69,13 +73,13 @@ mod tests { let taken = struct_arr .take(indices.into_array()) .unwrap() - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!(taken.len(), 1); assert!( taken .into_array() - .all_invalid(&mut array_session().create_execution_ctx()) + .all_invalid(&mut SESSION.create_execution_ctx()) .unwrap() ); } @@ -89,13 +93,13 @@ mod tests { assert_arrays_eq!( taken, PrimitiveArray::from_option_iter([None::]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } #[test] fn take_field_struct() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let struct_arr = StructArray::from_fields(&[("a", PrimitiveArray::from_iter(0..10).into_array())]) .unwrap(); @@ -118,7 +122,7 @@ mod tests { &StructArray::try_new(FieldNames::empty(), vec![], 5, Validity::NonNullable) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -153,7 +157,7 @@ mod tests { ) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -168,18 +172,14 @@ mod tests { ); let casted = array.cast(non_nullable_dtype.clone()).unwrap(); assert_eq!(casted.dtype(), &non_nullable_dtype); - assert_arrays_eq!(casted, array, &mut array_session().create_execution_ctx()); + assert_arrays_eq!(casted, array, &mut SESSION.create_execution_ctx()); let nullable_dtype = DType::Struct(StructFields::new(FieldNames::default(), vec![]), Nullable); let casted = array.cast(nullable_dtype.clone()).unwrap(); assert_eq!(casted.dtype(), &nullable_dtype); let expected = StructArray::new(FieldNames::empty(), vec![], 5, Validity::AllValid); - assert_arrays_eq!( - casted, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(casted, expected, &mut SESSION.create_execution_ctx()); } #[test] @@ -251,7 +251,7 @@ mod tests { outer_validity, ) }; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let top_level_non_nullable = fully_nullable_array.dtype().as_nonnullable(); let casted = fully_nullable_array .cast(top_level_non_nullable.clone()) @@ -325,7 +325,7 @@ mod tests { #[test] fn test_empty_struct_is_constant() { let array = StructArray::new_fieldless_with_len(2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = is_constant(&array.into_array(), &mut ctx) .vortex_expect("operation should succeed in test"); assert!(result); @@ -337,7 +337,7 @@ mod tests { &StructArray::try_new(FieldNames::empty(), vec![], 5, Validity::NonNullable) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -354,7 +354,7 @@ mod tests { &StructArray::try_new(["xs", "ys"].into(), vec![xs, ys], 5, Validity::NonNullable) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -376,7 +376,7 @@ mod tests { ) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -405,7 +405,7 @@ mod tests { ) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -418,7 +418,7 @@ mod tests { &StructArray::try_new(["xs", "ys"].into(), vec![xs, ys], 1, Validity::NonNullable) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -442,7 +442,7 @@ mod tests { ) .unwrap() .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } @@ -492,9 +492,6 @@ mod tests { StructArray::try_new(["xs", "ys"].into(), vec![xs, ys], 100, Validity::NonNullable).unwrap() })] fn test_struct_consistency(#[case] array: StructArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/struct_/compute/rules.rs b/vortex-array/src/arrays/struct_/compute/rules.rs index 87969cf85e6..f7bcd750030 100644 --- a/vortex-array/src/arrays/struct_/compute/rules.rs +++ b/vortex-array/src/arrays/struct_/compute/rules.rs @@ -151,7 +151,7 @@ mod tests { use crate::optimizer::kernels::KernelSession; use crate::scalar::Scalar; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_struct_cast_field_reorder() { diff --git a/vortex-array/src/arrays/struct_/compute/zip.rs b/vortex-array/src/arrays/struct_/compute/zip.rs index d740168a51a..a6dc944d019 100644 --- a/vortex-array/src/arrays/struct_/compute/zip.rs +++ b/vortex-array/src/arrays/struct_/compute/zip.rs @@ -70,20 +70,24 @@ impl ZipKernel for Struct { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::StructArray; use crate::builtins::ArrayBuiltins; use crate::dtype::FieldNames; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_validity_zip_both_validity_array() { - let ctx = array_session().create_execution_ctx(); + let ctx = SESSION.create_execution_ctx(); // Both structs have Validity::Array let if_true = StructArray::new( FieldNames::from_iter(["field"]), @@ -122,7 +126,7 @@ mod tests { #[test] fn test_validity_zip_allvalid_and_array() { - let ctx = array_session().create_execution_ctx(); + let ctx = SESSION.create_execution_ctx(); let if_true = StructArray::new( FieldNames::from_iter(["a"]), vec![PrimitiveArray::from_iter([1, 2, 3, 4]).into_array()], diff --git a/vortex-array/src/arrays/struct_/tests.rs b/vortex-array/src/arrays/struct_/tests.rs index 9794c1dcee2..32eb9a3419d 100644 --- a/vortex-array/src/arrays/struct_/tests.rs +++ b/vortex-array/src/arrays/struct_/tests.rs @@ -1,13 +1,15 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; @@ -22,9 +24,11 @@ use crate::dtype::Nullability; use crate::dtype::PType; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_project() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let xs = PrimitiveArray::new(buffer![0i64, 1, 2, 3, 4], Validity::NonNullable); let ys = VarBinArray::from_vec( vec!["a", "b", "c", "d", "e"], @@ -67,7 +71,7 @@ fn test_project() { #[test] fn test_remove_column() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let xs = PrimitiveArray::new(buffer![0i64, 1, 2, 3, 4], Validity::NonNullable); let ys = PrimitiveArray::new(buffer![4u64, 5, 6, 7, 8], Validity::NonNullable); @@ -113,7 +117,7 @@ fn test_remove_column() { #[test] fn test_duplicate_field_names() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test that StructArray allows duplicate field names and returns the first match let field1 = buffer![1i32, 2, 3].into_array(); let field2 = buffer![10i32, 20, 30].into_array(); @@ -161,12 +165,12 @@ fn test_uncompressed_size_in_bytes() -> VortexResult<()> { let canonical_size = struct_array .clone() .into_array() - .execute::(&mut array_session().create_execution_ctx())? + .execute::(&mut SESSION.create_execution_ctx())? .into_array() .nbytes(); let uncompressed_size = struct_array .statistics() - .compute_uncompressed_size_in_bytes(&mut array_session().create_execution_ctx()); + .compute_uncompressed_size_in_bytes(&mut SESSION.create_execution_ctx()); assert_eq!(canonical_size, 2); assert_eq!(uncompressed_size, Some(4000)); @@ -175,7 +179,7 @@ fn test_uncompressed_size_in_bytes() -> VortexResult<()> { #[test] fn test_push_validity_into_children_drops_struct_validity() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let struct_array = StructArray::try_new( FieldNames::from(["a", "b"]), vec![ @@ -214,7 +218,7 @@ fn test_push_validity_into_children_drops_struct_validity() -> VortexResult<()> #[test] fn test_push_validity_into_children_preserves_struct_validity() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let struct_array = StructArray::try_new( FieldNames::from(["a", "b"]), vec![ @@ -263,7 +267,7 @@ fn test_push_validity_into_children_preserves_struct_validity() -> VortexResult< #[test] fn test_push_validity_into_children_intersects_field_validity() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Fields carry their own nulls (a at row 1, b at row 2) and the struct is null at row 1, // so pushing intersects both levels rather than overwriting the fields. @@ -296,7 +300,7 @@ fn test_push_validity_into_children_intersects_field_validity() -> VortexResult< #[test] fn test_push_validity_into_children_all_invalid() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let struct_array = StructArray::try_new( FieldNames::from(["a", "b"]), vec![ @@ -326,7 +330,7 @@ fn test_push_validity_into_children_all_invalid() -> VortexResult<()> { #[test] fn test_push_validity_into_children_no_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // No nulls: the fields are untouched, only the top-level nullability changes. let struct_array = StructArray::try_new( diff --git a/vortex-array/src/arrays/union/tests/mod.rs b/vortex-array/src/arrays/union/tests/mod.rs index 0833ba57d94..9a677da7366 100644 --- a/vortex-array/src/arrays/union/tests/mod.rs +++ b/vortex-array/src/arrays/union/tests/mod.rs @@ -1,12 +1,15 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use vortex_buffer::ByteBufferMut; use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_err; use vortex_mask::Mask; +use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use crate::ArrayContext; @@ -15,7 +18,6 @@ use crate::IntoArray; use crate::VortexSessionExecute; use crate::aggregate_fn::fns::uncompressed_size_in_bytes::UncompressedSizeOpts; use crate::aggregate_fn::fns::uncompressed_size_in_bytes::uncompressed_size_in_bytes; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; @@ -32,6 +34,8 @@ use crate::serde::SerializeOptions; use crate::serde::SerializedArray; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + mod take; fn variants() -> VortexResult { @@ -81,7 +85,7 @@ fn nullable_union_array() -> VortexResult { #[test] fn scalar_at_uses_type_id_indirection() -> VortexResult<()> { let array = union_array()?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( array.child_by_name("flag")?.dtype(), @@ -151,7 +155,7 @@ fn invalid_type_id_panics_when_accessed() { ], ) .vortex_expect("structurally valid UnionArray"); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let _scalar = array .execute_scalar(1, &mut ctx) @@ -162,7 +166,7 @@ fn invalid_type_id_panics_when_accessed() { fn outer_nulls_are_independent_from_inner_nulls() -> VortexResult<()> { let variants = nullable_variants()?; let array = nullable_union_array()?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( array.dtype(), @@ -198,7 +202,7 @@ fn masking_adds_outer_nulls_only() -> VortexResult<()> { let masked = union_array()? .into_array() .mask(BoolArray::from_iter([true, false, true]).into_array())?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let masked = masked.execute::(&mut ctx)?; assert_eq!( @@ -224,7 +228,7 @@ fn masking_adds_outer_nulls_only() -> VortexResult<()> { #[test] fn slice_and_filter_preserve_sparse_alignment() -> VortexResult<()> { let array = union_array()?.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let sliced = array.slice(1..3)?; let filtered = array.filter(Mask::from_iter([true, false, true]))?; @@ -257,7 +261,7 @@ fn slice_and_filter_preserve_sparse_alignment() -> VortexResult<()> { /// value and whose unselected children hold placeholders. #[test] fn constant_union_canonicalizes_to_sparse_union() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let i32_variant = DType::Primitive(PType::I32, Nullability::NonNullable); let i64_variant = DType::Primitive(PType::I64, Nullability::Nullable); @@ -305,7 +309,7 @@ fn constant_union_canonicalizes_to_sparse_union() -> VortexResult<()> { #[test] fn constant_union_reports_uncompressed_size() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scalar = Scalar::union(variants()?, 5, 10i32.into(), Nullability::NonNullable)?; // Four `u8` type IDs, four `i32` rows, and four `bool` placeholder bits rounded up to a byte. @@ -322,7 +326,7 @@ fn constant_union_reports_uncompressed_size() -> VortexResult<()> { #[test] fn serde_roundtrip() -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); let mut execution_ctx = session.create_execution_ctx(); for array in [union_array()?, nullable_union_array()?] { let dtype = array.dtype().clone(); diff --git a/vortex-array/src/arrays/union/tests/take.rs b/vortex-array/src/arrays/union/tests/take.rs index 0088ace43b2..ba0de72c01f 100644 --- a/vortex-array/src/arrays/union/tests/take.rs +++ b/vortex-array/src/arrays/union/tests/take.rs @@ -1,9 +1,12 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_error::VortexResult; use vortex_error::vortex_err; +use vortex_session::VortexSession; use super::nullable_union_array; use super::nullable_variants; @@ -13,7 +16,6 @@ use crate::ArrayRef; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::Union; use crate::arrays::UnionArray; @@ -25,6 +27,8 @@ use crate::dtype::Nullability; use crate::dtype::PType; use crate::scalar::Scalar; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Take `indices`, asserting the result reduced back to a union instead of staying a dictionary. #[track_caller] fn take(array: &UnionArray, indices: ArrayRef) -> VortexResult { @@ -39,7 +43,7 @@ fn take(array: &UnionArray, indices: ArrayRef) -> VortexResult { /// Assert that `array` holds exactly `expected`, row for row. #[track_caller] fn assert_rows(array: &UnionArray, expected: Vec) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(array.len(), expected.len()); for (index, expected) in expected.into_iter().enumerate() { @@ -145,7 +149,7 @@ fn take_from_empty_union_is_all_null() -> VortexResult<()> { let via_take = empty .take(indices.clone())? - .execute::(&mut array_session().create_execution_ctx())? + .execute::(&mut SESSION.create_execution_ctx())? .into_union(); let via_reduce = ::take(empty.as_::(), &indices)? .ok_or_else(|| vortex_err!("Union take must never decline"))? @@ -162,10 +166,7 @@ fn take_from_empty_union_is_all_null() -> VortexResult<()> { #[case::non_nullable(union_array())] #[case::nullable(nullable_union_array())] fn take_conformance(#[case] array: VortexResult) -> VortexResult<()> { - test_take_conformance( - &array?.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&array?.into_array(), &mut SESSION.create_execution_ctx()); Ok(()) } diff --git a/vortex-array/src/arrays/validation_tests.rs b/vortex-array/src/arrays/validation_tests.rs index e32e01312d4..938c0e8a709 100644 --- a/vortex-array/src/arrays/validation_tests.rs +++ b/vortex-array/src/arrays/validation_tests.rs @@ -9,15 +9,16 @@ #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use vortex_buffer::Buffer; use vortex_buffer::ByteBuffer; use vortex_buffer::buffer; use vortex_error::VortexError; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::DecimalArray; use crate::arrays::FixedSizeListArray; @@ -32,6 +33,8 @@ mod tests { use crate::dtype::PType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_chunked_array_validation_failure_mismatched_dtypes() { // Invalid case: chunks have different dtypes. @@ -65,7 +68,7 @@ mod tests { #[test] fn test_list_array_validation_failure_offsets_out_of_bounds() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Invalid case: last offset exceeds elements length. let elements = buffer![1i32, 2, 3].into_array(); let offsets = buffer![0i64, 2, 5].into_array(); // 5 > 3. @@ -96,7 +99,7 @@ mod tests { Arc::new([]), DType::Utf8(Nullability::NonNullable), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); assert!(result.is_ok()); } @@ -116,7 +119,7 @@ mod tests { buffers, DType::Binary(Nullability::NonNullable), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); assert!(matches!(result, Err(VortexError::InvalidArgument(_, _)))); @@ -152,7 +155,7 @@ mod tests { #[case] validity: Validity, #[case] ok: bool, ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let nullability = if matches!(validity, Validity::NonNullable) { Nullability::NonNullable } else { diff --git a/vortex-array/src/arrays/varbin/builder.rs b/vortex-array/src/arrays/varbin/builder.rs index 9842336fb21..47e7e4e025d 100644 --- a/vortex-array/src/arrays/varbin/builder.rs +++ b/vortex-array/src/arrays/varbin/builder.rs @@ -717,14 +717,15 @@ fn prefix_sums>(lengths: &[P]) -> impl Iterator = LazyLock::new(VortexSession::empty); + #[test] fn test_builder() { let mut builder = VarBinBuilder::::with_capacity_in( @@ -755,20 +758,20 @@ mod tests { assert_eq!(array.dtype().nullability(), Nullable); assert_eq!( array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::utf8("hello".to_string(), Nullable) ); assert!( array - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert_arrays_eq!( array, VarBinViewArray::from_iter_nullable_str([Some("hello"), None, Some("world")]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -788,7 +791,7 @@ mod tests { ) .into_array() .slice(1..4)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = with_offsets(large_offsets, source.dtype().clone(), |builder| { source.append_to_builder(builder, &mut ctx) @@ -847,7 +850,7 @@ mod tests { #[test] fn append_decoded_writes_into_the_builder_storage() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinBuilder::::new_in( DType::Utf8(Nullable), vortex_buffer::BufferAllocatorRef::static_ref(), @@ -979,7 +982,7 @@ mod tests { #[case(false)] #[case(true)] fn test_array_builder_methods(#[case] large_offsets: bool) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = with_offsets(large_offsets, DType::Utf8(Nullable), |builder| { builder.reserve_exact(3); builder.append_zero(); @@ -1013,7 +1016,7 @@ mod tests { [None, None, Some("hello"), None, Some(long)], DType::Utf8(Nullable), ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = with_offsets(large_offsets, expected.dtype().clone(), |builder| { all_null @@ -1040,7 +1043,7 @@ mod tests { #[case::i32(VarBinBuilder::::new_in(DType::Utf8(Nullable), vortex_buffer::BufferAllocatorRef::static_ref()))] #[case::i64(VarBinBuilder::::new_in(DType::Utf8(Nullable), vortex_buffer::BufferAllocatorRef::static_ref()))] fn append_to_every_offset_width(#[case] mut builder: impl ArrayBuilder) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let long = "a string that is far too long to be inlined in a view"; let values = [Some("hello"), None, Some(long), Some("")]; diff --git a/vortex-array/src/arrays/varbin/compute/cast.rs b/vortex-array/src/arrays/varbin/compute/cast.rs index 8d4e6b32ef5..09b68449103 100644 --- a/vortex-array/src/arrays/varbin/compute/cast.rs +++ b/vortex-array/src/arrays/varbin/compute/cast.rs @@ -88,7 +88,7 @@ mod tests { use crate::dtype::DType; use crate::dtype::Nullability; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[rstest] #[case( diff --git a/vortex-array/src/arrays/varbin/compute/compare.rs b/vortex-array/src/arrays/varbin/compute/compare.rs index a0e7daa33db..ab2abce91c9 100644 --- a/vortex-array/src/arrays/varbin/compute/compare.rs +++ b/vortex-array/src/arrays/varbin/compute/compare.rs @@ -173,11 +173,13 @@ fn value_cmp(bytes: &[u8], start: usize, end: usize, constant: &[u8]) -> Orderin #[cfg(test)] mod test { + use std::sync::LazyLock; + use vortex_buffer::ByteBuffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::VarBinArray; @@ -189,9 +191,11 @@ mod test { use crate::scalar::Scalar; use crate::scalar_fn::fns::operators::Operator; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_binary_compare() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinArray::from_iter( [Some(b"abc".to_vec()), None, Some(b"def".to_vec())], DType::Binary(Nullability::Nullable), @@ -217,7 +221,7 @@ mod test { #[test] fn varbinview_compare() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinArray::from_iter( [Some(b"abc".to_vec()), None, Some(b"def".to_vec())], DType::Binary(Nullability::Nullable), @@ -241,11 +245,13 @@ mod test { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::ByteBuffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::VarBinArray; @@ -257,6 +263,8 @@ mod tests { use crate::scalar::Scalar; use crate::scalar_fn::fns::operators::Operator; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_null_compare() { let arr = VarBinArray::from_iter([Some("h")], DType::Utf8(Nullability::NonNullable)); @@ -270,7 +278,7 @@ mod tests { assert_arrays_eq!( result, BoolArray::from_iter([Some(false)]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -281,7 +289,7 @@ mod tests { /// [`CompareKernel`]: super::CompareKernel #[test] fn varbin_i64_offsets_compare_constant() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinBuilder::::with_capacity_in( DType::Utf8(Nullability::NonNullable), 3, @@ -306,7 +314,7 @@ mod tests { #[test] fn varbin_i64_offsets_compare_constant_binary() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinBuilder::::with_capacity_in( DType::Binary(Nullability::NonNullable), 3, diff --git a/vortex-array/src/arrays/varbin/compute/filter.rs b/vortex-array/src/arrays/varbin/compute/filter.rs index 9fc00dc78aa..47f740b46ac 100644 --- a/vortex-array/src/arrays/varbin/compute/filter.rs +++ b/vortex-array/src/arrays/varbin/compute/filter.rs @@ -233,12 +233,14 @@ fn filter_select_var_bin_by_index_primitive_offset = LazyLock::new(VortexSession::empty); + #[test] fn filter_var_bin_test() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = VarBinArray::from_vec( vec![ b"hello".as_slice(), @@ -269,7 +273,7 @@ mod test { #[test] fn filter_var_bin_slice_test() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = VarBinArray::from_vec( vec![ b"hello".as_slice(), @@ -294,7 +298,7 @@ mod test { #[test] fn filter_var_bin_slice_null() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bytes = [ b"one".as_slice(), b"two".as_slice(), @@ -332,7 +336,7 @@ mod test { #[test] fn filter_varbin_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bytes = [b"".as_slice(), b"two".as_slice(), b"two".as_slice()] .into_iter() .flat_map(|x| x.iter().cloned()) @@ -351,7 +355,7 @@ mod test { #[test] fn filter_varbin_all_null() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let offsets = buffer![0, 0, 0, 0].into_array(); let validity = Validity::Array(BoolArray::from_iter([false, false, false]).into_array()); let arr = VarBinArray::try_new( @@ -375,18 +379,12 @@ mod test { vec!["hello", "world", "filter", "good", "bye"], DType::Utf8(NonNullable), ); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); let array = VarBinArray::from_iter( vec![Some("hello"), None, Some("filter"), Some("good"), None], DType::Utf8(Nullable), ); - test_filter_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_filter_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/varbin/compute/mask.rs b/vortex-array/src/arrays/varbin/compute/mask.rs index d47935ec7de..5f75ccc3839 100644 --- a/vortex-array/src/arrays/varbin/compute/mask.rs +++ b/vortex-array/src/arrays/varbin/compute/mask.rs @@ -31,32 +31,31 @@ impl MaskReduce for VarBin { #[cfg(test)] mod test { + use std::sync::LazyLock; + + use vortex_session::VortexSession; + use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinArray; use crate::compute::conformance::mask::test_mask_conformance; use crate::dtype::DType; use crate::dtype::Nullability; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_mask_var_bin_array() { let array = VarBinArray::from_vec( vec!["hello", "world", "filter", "good", "bye"], DType::Utf8(Nullability::NonNullable), ); - test_mask_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_mask_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); let array = VarBinArray::from_iter( vec![Some("hello"), None, Some("filter"), Some("good"), None], DType::Utf8(Nullability::Nullable), ); - test_mask_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_mask_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/varbin/compute/mod.rs b/vortex-array/src/arrays/varbin/compute/mod.rs index ea1a387008f..24290a785cf 100644 --- a/vortex-array/src/arrays/varbin/compute/mod.rs +++ b/vortex-array/src/arrays/varbin/compute/mod.rs @@ -14,16 +14,20 @@ pub use take::take_varbin; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinArray; use crate::compute::conformance::consistency::test_array_consistency; use crate::dtype::DType; use crate::dtype::Nullability; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] // UTF-8 strings #[case::str_non_nullable(VarBinArray::from_iter( @@ -64,9 +68,6 @@ mod tests { DType::Utf8(Nullability::NonNullable), ))] fn test_varbin_consistency(#[case] array: VarBinArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/varbin/compute/take.rs b/vortex-array/src/arrays/varbin/compute/take.rs index 4d7c38d2dcc..d6993d18fc8 100644 --- a/vortex-array/src/arrays/varbin/compute/take.rs +++ b/vortex-array/src/arrays/varbin/compute/take.rs @@ -814,15 +814,16 @@ fn take_nullable( #[cfg(test)] mod tests { use std::iter; + use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::ByteBuffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinArray; use crate::arrays::VarBinViewArray; use crate::arrays::varbin::compute::take::PrimitiveArray; @@ -833,13 +834,15 @@ mod tests { use crate::dtype::PType; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_null_take() { let arr = VarBinArray::from_iter([Some("h")], DType::Utf8(Nullability::NonNullable)); let idx1: PrimitiveArray = (0..1).collect(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( arr.take(idx1.into_array()).unwrap(), VarBinViewArray::from_iter_str(["h"]), @@ -870,15 +873,12 @@ mod tests { ))] #[case(VarBinArray::from_iter(["single"].map(Some), DType::Utf8(Nullability::NonNullable)))] fn test_take_varbin_conformance(#[case] array: VarBinArray) { - test_take_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } #[test] fn test_take_overflow() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scream = iter::once("a").cycle().take(128).collect::(); let bytes = ByteBuffer::copy_from(scream.as_bytes()); let offsets = buffer![0u8, 128u8].into_array(); @@ -922,7 +922,7 @@ mod tests { &DType::Primitive(expected, Nullability::NonNullable) ); assert_eq!(array.len(), 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for (index, value) in [0, max_offset as u64].into_iter().enumerate() { assert_eq!( array @@ -937,7 +937,7 @@ mod tests { #[test] fn test_offset_widen_values() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let big = u32::MAX as usize + 5; let mut sink = super::Offsets::with_capacity(PType::U32, 3); sink.push(0); @@ -951,7 +951,7 @@ mod tests { #[test] fn test_take_signed() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinArray::new( buffer![0i32, 5, 10].into_array(), ByteBuffer::copy_from(b"helloworld"), diff --git a/vortex-array/src/arrays/varbin/tests.rs b/vortex-array/src/arrays/varbin/tests.rs index 7de69b644f1..5e3074529ae 100644 --- a/vortex-array/src/arrays/varbin/tests.rs +++ b/vortex-array/src/arrays/varbin/tests.rs @@ -1,16 +1,18 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::fixture; use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::VarBinArray; use crate::arrays::VarBinViewArray; use crate::arrays::varbin::offsets_tile_utf8; @@ -20,9 +22,11 @@ use crate::dtype::Nullability; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[fixture] fn binary_array() -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = Buffer::copy_from("hello worldhello world this is a long string".as_bytes()); let offsets = buffer![0, 11, 44].into_array(); @@ -39,7 +43,7 @@ fn binary_array() -> ArrayRef { #[rstest] pub fn test_scalar_at(binary_array: ArrayRef) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for (index, value) in ["hello world", "hello world this is a long string"] .into_iter() .enumerate() @@ -58,7 +62,7 @@ pub fn test_scalar_at(binary_array: ArrayRef) { #[rstest] pub fn slice_array(binary_array: ArrayRef) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let binary_arr = binary_array.slice(1..2).unwrap(); assert_arrays_eq!( binary_arr, @@ -89,7 +93,7 @@ fn test_offsets_tile_utf8_rejects_negative_offsets() { #[case::negative_first(buffer![-1i32, 2, 3].into_array())] #[case::beyond_bytes(buffer![0i32, 2, 6].into_array())] fn try_new_rejects_invalid_offsets(#[case] offsets: ArrayRef) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = Buffer::copy_from("hello".as_bytes()); let result = VarBinArray::try_new( @@ -105,7 +109,7 @@ fn try_new_rejects_invalid_offsets(#[case] offsets: ArrayRef) { #[test] fn try_new_allows_nonzero_first_offset() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = Buffer::copy_from("hello".as_bytes()); let offsets = buffer![1i32, 3, 5].into_array(); @@ -120,14 +124,14 @@ fn try_new_allows_nonzero_first_offset() -> VortexResult<()> { assert_arrays_eq!( array, VarBinViewArray::from_iter_bin([b"el", b"lo"]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } #[test] fn try_new_rejects_unsorted_utf8_offsets_at_null_row() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Every non-null string is valid UTF-8, so only the offsets check rejects the null row 3..1. let values = Buffer::copy_from("hello".as_bytes()); let offsets = buffer![0i32, 3, 1, 5].into_array(); diff --git a/vortex-array/src/arrays/varbin/vtable/canonical.rs b/vortex-array/src/arrays/varbin/vtable/canonical.rs index 9493e4189a6..4ecd6127e0e 100644 --- a/vortex-array/src/arrays/varbin/vtable/canonical.rs +++ b/vortex-array/src/arrays/varbin/vtable/canonical.rs @@ -43,12 +43,14 @@ pub(crate) fn varbin_to_canonical( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::VarBinArray; use crate::arrays::VarBinViewArray; @@ -58,6 +60,8 @@ mod tests { use crate::dtype::DType; use crate::dtype::Nullability; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(DType::Utf8(Nullability::Nullable))] #[case(DType::Binary(Nullability::Nullable))] @@ -77,13 +81,13 @@ mod tests { let varbin = varbin.slice(1..4).unwrap(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let canonical = varbin.execute::(&mut ctx).unwrap(); assert_eq!(canonical.dtype(), &dtype); assert!( !canonical - .is_valid(0, &mut array_session().create_execution_ctx()) + .is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); @@ -100,7 +104,7 @@ mod tests { #[case(DType::Utf8(Nullability::NonNullable))] #[case(DType::Binary(Nullability::NonNullable))] fn test_canonical_varbin_unsliced(#[case] dtype: DType) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let varbin = VarBinArray::from_iter_nonnull(["foo", "bar", "baz"], dtype.clone()); let expected = match dtype { DType::Utf8(_) => VarBinViewArray::from_iter_str(["foo", "bar", "baz"]), @@ -117,7 +121,7 @@ mod tests { #[case(DType::Utf8(Nullability::Nullable))] #[case(DType::Binary(Nullability::Nullable))] fn append_varbin_to_varbinview_builder(#[case] dtype: DType) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let long = "a value long enough that its view has to reference a buffer"; let longer = "another value long enough that its view has to reference a buffer"; @@ -165,7 +169,7 @@ mod tests { /// drops the fully-inlined heap. #[test] fn append_varbin_to_a_compacting_builder_still_compacts() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Utf8(Nullability::NonNullable); // Every value inlines, so nothing references the value bytes at all. let array = VarBinArray::from_iter_nonnull(["short", "tiny", "small"], dtype.clone()); @@ -198,7 +202,7 @@ mod tests { fn test_canonical_varbin_empty() { let varbin = VarBinArray::from_iter_nonnull([] as [&str; 0], DType::Utf8(Nullability::NonNullable)); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( varbin, VarBinViewArray::from_iter_str([] as [&str; 0]), diff --git a/vortex-array/src/arrays/varbinview/compact.rs b/vortex-array/src/arrays/varbinview/compact.rs index d297f81f780..b993c1e8447 100644 --- a/vortex-array/src/arrays/varbinview/compact.rs +++ b/vortex-array/src/arrays/varbinview/compact.rs @@ -197,20 +197,24 @@ impl BufferUtilization { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinArray; use crate::arrays::VarBinViewArray; use crate::assert_arrays_eq; use crate::dtype::DType; use crate::dtype::Nullability; + + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_optimize_compacts_buffers() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create a VarBinViewArray with some long strings that will create multiple buffers let excluded = "unused long string".repeat(100); let original = VarBinViewArray::from_iter_nullable_str([ @@ -247,7 +251,7 @@ mod tests { #[test] fn test_optimize_with_long_strings() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create strings that are definitely longer than 12 bytes let long_string_1 = "this is definitely a very long string that exceeds the inline limit"; let long_string_2 = "another extremely long string that also needs external buffer storage"; @@ -265,7 +269,7 @@ mod tests { let indices = buffer![0u32, 2u32].into_array(); let taken = original.take(indices).unwrap(); let taken_array = taken - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); let optimized_array = taken_array.compact_with_threshold(1.0, &mut ctx).unwrap(); @@ -287,7 +291,7 @@ mod tests { #[test] fn test_optimize_no_buffers() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create an array with only short strings (all inlined) let original = VarBinViewArray::from_iter_str(["a", "bb", "ccc", "dddd"]); @@ -304,7 +308,7 @@ mod tests { #[test] fn test_optimize_single_buffer() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create an array that naturally has only one buffer let str1 = "this is a long string that goes into a buffer"; let str2 = "another long string in the same buffer"; @@ -324,7 +328,7 @@ mod tests { #[test] fn test_selective_compaction_with_threshold_zero() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // threshold=0 should keep all buffers (no compaction) let original = VarBinViewArray::from_iter_str([ "this is a longer string that will be stored in a buffer", @@ -338,7 +342,7 @@ mod tests { let indices = buffer![0u32].into_array(); let taken = original.take(indices).unwrap(); let taken = taken - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); // Compact with threshold=0 (should not compact) let compacted = taken.compact_with_threshold(0.0, &mut ctx).unwrap(); @@ -352,7 +356,7 @@ mod tests { #[test] fn test_selective_compaction_with_high_threshold() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // threshold=1.0 should compact any buffer with waste let original = VarBinViewArray::from_iter_str([ "this is a longer string that will be stored in a buffer", @@ -364,7 +368,7 @@ mod tests { let indices = buffer![0u32, 2u32].into_array(); let taken = original.take(indices).unwrap(); let taken = taken - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); let original_buffers = taken.data_buffers().len(); @@ -389,7 +393,7 @@ mod tests { #[test] fn test_selective_compaction_preserves_well_utilized_buffers() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create an array with multiple strings in one buffer (well-utilized) let str1 = "first long string that needs external buffer storage"; let str2 = "second long string also in buffer"; @@ -417,7 +421,7 @@ mod tests { #[test] fn test_selective_compaction_with_mixed_utilization() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create array with some long strings let strings: Vec = (0..10) .map(|i| { @@ -434,7 +438,7 @@ mod tests { let indices_array = buffer![0u32, 2u32, 4u32, 6u32, 8u32].into_array(); let taken = original.take(indices_array).unwrap(); let taken = taken - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); // Compact with moderate threshold @@ -449,7 +453,7 @@ mod tests { #[test] fn test_slice_strategy_with_contiguous_range() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create array with strings that will be in one buffer let strings: Vec = (0..20) .map(|i| format!("this is a long string number {} for slice test", i)) @@ -461,7 +465,7 @@ mod tests { let indices_array = buffer![0u32, 1u32, 2u32, 3u32, 4u32].into_array(); let taken = original.take(indices_array).unwrap(); let taken = taken - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) .unwrap(); // Get buffer stats before compaction let original_ptr = taken.buffer(0).as_ptr(); @@ -506,7 +510,7 @@ mod tests { #[case] expected_bytes: u64, #[case] expected_utils: &[f64], ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( arr.count_referenced_bytes(&mut ctx).unwrap(), expected_bytes diff --git a/vortex-array/src/arrays/varbinview/compute/cast.rs b/vortex-array/src/arrays/varbinview/compute/cast.rs index a857953c471..19b669f2eac 100644 --- a/vortex-array/src/arrays/varbinview/compute/cast.rs +++ b/vortex-array/src/arrays/varbinview/compute/cast.rs @@ -87,7 +87,7 @@ mod tests { use crate::dtype::DType; use crate::dtype::Nullability; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[rstest] #[case( diff --git a/vortex-array/src/arrays/varbinview/compute/fill_null.rs b/vortex-array/src/arrays/varbinview/compute/fill_null.rs index b9cf4d7c947..cd3c9bfd10e 100644 --- a/vortex-array/src/arrays/varbinview/compute/fill_null.rs +++ b/vortex-array/src/arrays/varbinview/compute/fill_null.rs @@ -81,12 +81,14 @@ impl FillNullKernel for VarBinView { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinArray; use crate::arrays::VarBinViewArray; use crate::assert_arrays_eq; @@ -95,13 +97,15 @@ mod tests { use crate::dtype::Nullability; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + const LONG: &str = "a value that is too long to inline"; #[rstest] #[case::inlined_fill("fill", 0)] #[case::outlined_fill("a fill value that is too long to inline", 1)] fn fill_null_utf8(#[case] fill: &str, #[case] added_buffers: usize) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_nullable_str([None, Some("short"), None, Some(LONG), None]); let input_buffers = array.data_buffers().len(); @@ -123,7 +127,7 @@ mod tests { #[test] fn fill_null_binary_with_nullable_fill() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_nullable_bin([Some(b"a".as_slice()), None]); let filled = array @@ -146,7 +150,7 @@ mod tests { #[test] fn fill_null_varbin_input() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinArray::from_nullable_strs(vec![Some("a"), None, Some(LONG)]); let filled = array diff --git a/vortex-array/src/arrays/varbinview/compute/mask.rs b/vortex-array/src/arrays/varbinview/compute/mask.rs index 601ae402a6a..8869f816600 100644 --- a/vortex-array/src/arrays/varbinview/compute/mask.rs +++ b/vortex-array/src/arrays/varbinview/compute/mask.rs @@ -34,17 +34,22 @@ impl MaskReduce for VarBinView { #[cfg(test)] mod tests { + use std::sync::LazyLock; + + use vortex_session::VortexSession; + use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinViewArray; use crate::compute::conformance::mask::test_mask_conformance; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn take_mask_var_bin_view_array() { test_mask_conformance( &VarBinViewArray::from_iter_str(["one", "two", "three", "four", "five"]).into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); test_mask_conformance( @@ -56,7 +61,7 @@ mod tests { Some("five"), ]) .into_array(), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ); } } diff --git a/vortex-array/src/arrays/varbinview/compute/mod.rs b/vortex-array/src/arrays/varbinview/compute/mod.rs index 59d21880ef9..dab35219b5c 100644 --- a/vortex-array/src/arrays/varbinview/compute/mod.rs +++ b/vortex-array/src/arrays/varbinview/compute/mod.rs @@ -11,16 +11,20 @@ mod zip; #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinViewArray; use crate::compute::conformance::consistency::test_array_consistency; use crate::dtype::DType; use crate::dtype::Nullability; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] // From test_all_consistency #[case::varbinview_str(VarBinViewArray::from_iter( @@ -55,9 +59,6 @@ mod tests { None::<&str>, None, None, None ]))] fn test_varbinview_consistency(#[case] array: VarBinViewArray) { - test_array_consistency( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/varbinview/compute/take.rs b/vortex-array/src/arrays/varbinview/compute/take.rs index 56e599711eb..77c0ce44d08 100644 --- a/vortex-array/src/arrays/varbinview/compute/take.rs +++ b/vortex-array/src/arrays/varbinview/compute/take.rs @@ -225,14 +225,16 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::BitBuffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinViewArray; use crate::arrays::varbinview::compute::take::PrimitiveArray; use crate::compute::conformance::take::test_take_conformance; @@ -240,6 +242,8 @@ mod tests { use crate::dtype::Nullability::NonNullable; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn take_nullable() -> VortexResult<()> { let arr = VarBinViewArray::from_iter_nullable_str([ @@ -254,7 +258,7 @@ mod tests { let taken = arr.take(buffer![0, 3].into_array())?; assert!(taken.dtype().is_nullable()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let taken = taken.execute::(&mut ctx)?; let mask = taken.validity()?.execute_mask(taken.len(), &mut ctx)?; let result = (0..taken.len()) @@ -280,7 +284,7 @@ mod tests { let taken = arr.take(indices.into_array())?; assert!(taken.dtype().is_nullable()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let taken = taken.execute::(&mut ctx)?; let mask = taken.validity()?.execute_mask(taken.len(), &mut ctx)?; let result = (0..taken.len()) @@ -311,9 +315,6 @@ mod tests { ))] #[case(VarBinViewArray::from_iter(["single"].map(Some), DType::Utf8(NonNullable)))] fn test_take_varbinview_conformance(#[case] array: VarBinViewArray) { - test_take_conformance( - &array.into_array(), - &mut array_session().create_execution_ctx(), - ); + test_take_conformance(&array.into_array(), &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/arrays/varbinview/compute/zip.rs b/vortex-array/src/arrays/varbinview/compute/zip.rs index e4a76a30f5b..fdcfccbd0d5 100644 --- a/vortex-array/src/arrays/varbinview/compute/zip.rs +++ b/vortex-array/src/arrays/varbinview/compute/zip.rs @@ -210,17 +210,21 @@ fn push_view( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::VarBinViewArray; use crate::builtins::ArrayBuiltins; use crate::dtype::DType; use crate::dtype::Nullability; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn zip_varbinview_kernel_zips() -> VortexResult<()> { let a = VarBinViewArray::from_iter( @@ -249,14 +253,14 @@ mod tests { let mask = Mask::from_iter([true, false, true, false, false, true]); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let zipped = mask .clone() .into_array() .zip(a.into_array(), b.into_array())? .execute::(&mut ctx)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let validity_mask = zipped.validity()?.execute_mask(zipped.len(), &mut ctx)?; let values = (0..zipped.len()) .map(|i| { diff --git a/vortex-array/src/arrays/varbinview/resolved/tests.rs b/vortex-array/src/arrays/varbinview/resolved/tests.rs index fd135ba2f06..e1750409290 100644 --- a/vortex-array/src/arrays/varbinview/resolved/tests.rs +++ b/vortex-array/src/arrays/varbinview/resolved/tests.rs @@ -2,20 +2,23 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::VarBinViewArray; use crate::arrays::varbinview::BinaryView; use crate::dtype::DType; use crate::dtype::Nullability::NonNullable; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + const LONG: &str = "a value far too long to live inside its own view"; const ALPHA: &[u8] = b"alpha_long_value_0"; @@ -37,7 +40,7 @@ fn ref_view(value: &[u8], buffer_index: u32, offset: u32) -> VortexResult VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let views = Buffer::from_iter([ ref_view(ALPHA, 0, 0)?, BinaryView::new_inlined(SHORT), @@ -100,7 +103,7 @@ fn view_bytes_matches_bytes() -> VortexResult<()> { /// Slicing narrows the views, not the buffers. #[test] fn resolves_through_a_slice() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = two_buffer_array()? .slice(2..4)? .execute::(&mut ctx)?; diff --git a/vortex-array/src/arrays/varbinview/tests.rs b/vortex-array/src/arrays/varbinview/tests.rs index 337229e0f9a..54435775859 100644 --- a/vortex-array/src/arrays/varbinview/tests.rs +++ b/vortex-array/src/arrays/varbinview/tests.rs @@ -2,6 +2,7 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::BitBuffer; @@ -10,12 +11,12 @@ use vortex_buffer::ByteBuffer; use vortex_buffer::ByteBufferMut; use vortex_error::VortexResult; use vortex_error::vortex_err; +use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use crate::ArrayContext; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::VarBinView; use crate::arrays::VarBinViewArray; use crate::arrays::varbinview::BinaryView; @@ -28,9 +29,11 @@ use crate::serde::SerializeOptions; use crate::serde::SerializedArray; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] pub fn varbin_view() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let binary_arr = VarBinViewArray::from_iter_str(["hello world", "hello world this is a long string"]); assert_eq!(binary_arr.dtype(), &DType::Utf8(Nullability::NonNullable)); @@ -53,7 +56,7 @@ pub fn varbin_view() { #[test] pub fn slice_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let binary_arr = VarBinViewArray::from_iter_str(["hello world", "hello world this is a long string"]) .slice(1..2) @@ -77,7 +80,7 @@ pub fn binary_view_size_and_alignment() { #[test] pub fn validate_replaces_null_views() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let views = Buffer::::copy_from(vec![ BinaryView::new_inlined(b"ololo"), BinaryView::new_ref(13, *b"AAAA", 0xDEAD_BEEF, 0xF000_0000), @@ -112,7 +115,7 @@ pub fn deserialize_null_views() -> VortexResult<()> { let dtype = DType::Utf8(Nullability::Nullable); let buffer = BitBuffer::from_iter([true, false]); let validity = Validity::from_bit_buffer(buffer, Nullability::Nullable); - let session = array_session(); + let session = VortexSession::empty(); let array = VarBinViewArray::try_new( views.clone(), buffers, @@ -159,7 +162,7 @@ fn validate_utf8_views( views: Vec, validity: Validity, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let buffers: Arc<[ByteBuffer]> = Arc::new([ByteBuffer::from(buffer.to_vec())]); let views = Buffer::copy_from(views); let dtype = DType::Utf8(Nullability::Nullable); diff --git a/vortex-array/src/arrays/varbinview/vtable/mod.rs b/vortex-array/src/arrays/varbinview/vtable/mod.rs index e72a9e18677..f3d8d4147ed 100644 --- a/vortex-array/src/arrays/varbinview/vtable/mod.rs +++ b/vortex-array/src/arrays/varbinview/vtable/mod.rs @@ -276,18 +276,22 @@ impl VTable for VarBinView { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::ByteBufferMut; + use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use super::*; use crate::ArrayContext; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::assert_arrays_eq; use crate::serde::SerializeOptions; use crate::serde::SerializedArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_nullable_varbinview_serde_roundtrip() { let array = VarBinViewArray::from_iter_nullable_str([ @@ -300,13 +304,12 @@ mod tests { let dtype = array.dtype().clone(); let len = array.len(); - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array_ctx = ArrayContext::empty(); let serialized = array .clone() .into_array() - .serialize(&array_ctx, &session, &SerializeOptions::default()) + .serialize(&array_ctx, &SESSION, &SerializeOptions::default()) .unwrap(); let mut concat = ByteBufferMut::empty(); @@ -315,7 +318,7 @@ mod tests { } let parts = SerializedArray::try_from(concat.freeze()).unwrap(); let decoded = parts - .decode(&dtype, len, &ReadContext::new(array_ctx.to_ids()), &session) + .decode(&dtype, len, &ReadContext::new(array_ctx.to_ids()), &SESSION) .unwrap(); assert_arrays_eq!(decoded, array, &mut ctx); diff --git a/vortex-array/src/arrays/variant/mod.rs b/vortex-array/src/arrays/variant/mod.rs index fc332b0cd69..3a44a11019d 100644 --- a/vortex-array/src/arrays/variant/mod.rs +++ b/vortex-array/src/arrays/variant/mod.rs @@ -76,16 +76,18 @@ impl Array { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_error::vortex_err; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -103,6 +105,8 @@ mod tests { use crate::scalar::Scalar; use crate::scalar_fn::fns::variant_get::VariantPath; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn core_storage(len: usize) -> ArrayRef { ConstantArray::new( Scalar::variant(Scalar::primitive(1i32, Nullability::NonNullable)), @@ -136,7 +140,7 @@ mod tests { } fn execute_variant(array: ArrayRef) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let Canonical::Variant(variant) = array.execute::(&mut ctx)? else { return Err(vortex_err!("expected canonical variant array")); }; @@ -154,7 +158,7 @@ mod tests { let shredded = array .shredded() .ok_or_else(|| vortex_err!("expected shredded child"))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected_shredded_array = if let Some(values) = expected_shredded .iter() .copied() @@ -175,7 +179,7 @@ mod tests { ) -> VortexResult<()> { assert_eq!(array.len(), expected_core.len()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for (idx, expected) in expected_core.iter().enumerate() { let scalar = array.core_storage().execute_scalar(idx, &mut ctx)?; let variant = scalar.as_variant(); @@ -269,7 +273,7 @@ mod tests { let shredded = PrimitiveArray::from_option_iter([Some(10i32), Some(20), None]).into_array(); let variant = VariantArray::try_new(core_storage, Some(shredded))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for (idx, expected) in [Some(10i32), None, Some(3)].into_iter().enumerate() { let scalar = variant.execute_scalar(idx, &mut ctx)?; let variant = scalar.as_variant(); @@ -375,7 +379,7 @@ mod tests { #[test] fn variant_get_keeps_valid_shredded_rows_for_matching_dtype() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let core_storage = row_storage([1, 2, 3])?; let shredded = StructArray::try_from_iter([( "a", @@ -400,7 +404,7 @@ mod tests { #[test] fn variant_get_treats_value_and_typed_value_as_logical_field_names() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let core_storage = row_storage([1, 2, 3])?; let shredded = StructArray::try_from_iter([ ( diff --git a/vortex-array/src/builders/bool.rs b/vortex-array/src/builders/bool.rs index c5d7cdbbc9f..7a718e9244b 100644 --- a/vortex-array/src/builders/bool.rs +++ b/vortex-array/src/builders/bool.rs @@ -155,16 +155,18 @@ impl ArrayBuilder for BoolBuilder { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rand::RngExt; use rand::SeedableRng; use rand::prelude::StdRng; use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::bool::BoolArrayExt; use crate::assert_arrays_eq; @@ -176,6 +178,8 @@ mod tests { use crate::dtype::Nullability; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn make_opt_bool_chunks(len: usize, chunk_count: usize) -> (ArrayRef, Vec>) { let mut rng = StdRng::seed_from_u64(0); @@ -204,7 +208,7 @@ mod tests { let chunk_count = 10; let (chunk, expected) = make_opt_bool_chunks(len, chunk_count); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = builder_with_capacity_in( chunk.dtype(), len * chunk_count, @@ -231,7 +235,7 @@ mod tests { #[test] fn test_append_scalar() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = BoolBuilder::with_capacity_in( Nullability::Nullable, 10, diff --git a/vortex-array/src/builders/child.rs b/vortex-array/src/builders/child.rs index f84df289c19..923b7f76114 100644 --- a/vortex-array/src/builders/child.rs +++ b/vortex-array/src/builders/child.rs @@ -154,16 +154,18 @@ impl ChildBuilder { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::BufferAllocatorRef; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::ChildBuilder; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Chunked; use crate::arrays::Constant; use crate::arrays::ConstantArray; @@ -177,6 +179,8 @@ mod tests { use crate::dtype::PType::I32; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// An arbitrary array length. `ChildBuilder` treats no length specially, so the tests only /// need a length long enough to tell chunks apart. const CHUNK_LEN: usize = 64; @@ -193,7 +197,7 @@ mod tests { #[test] fn test_appended_arrays_are_kept_as_chunks() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ChildBuilder::with_capacity(&DType::from(I32), 0, BufferAllocatorRef::static_ref()); @@ -218,7 +222,7 @@ mod tests { /// too. A caller that wants the values copied appends them as scalars instead. #[test] fn test_short_arrays_are_kept_as_chunks_too() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ChildBuilder::with_capacity(&DType::from(I32), 0, BufferAllocatorRef::static_ref()); @@ -240,7 +244,7 @@ mod tests { #[test] fn test_scalars_interleaved_with_chunks_keep_their_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ChildBuilder::with_capacity(&DType::from(I32), 0, BufferAllocatorRef::static_ref()); @@ -263,7 +267,7 @@ mod tests { #[test] fn test_single_chunk_is_not_wrapped() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ChildBuilder::with_capacity(&DType::from(I32), 0, BufferAllocatorRef::static_ref()); @@ -279,7 +283,7 @@ mod tests { #[test] fn test_empty_arrays_never_become_chunks() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ChildBuilder::with_capacity(&DType::from(I32), 0, BufferAllocatorRef::static_ref()); let empty = constant(1, CHUNK_LEN).slice(0..0)?; @@ -304,7 +308,7 @@ mod tests { /// An empty child must still finish as an empty array rather than as an empty [`ChunkedArray`]. #[test] fn test_empty_child_finishes_without_chunks() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ChildBuilder::with_capacity(&DType::from(I32), 0, BufferAllocatorRef::static_ref()); @@ -324,7 +328,7 @@ mod tests { #[case::empty(0)] #[case::non_empty(CHUNK_LEN)] fn test_appending_a_mismatched_dtype_is_rejected(#[case] len: usize) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ChildBuilder::with_capacity(&DType::from(I32), 0, BufferAllocatorRef::static_ref()); @@ -335,7 +339,7 @@ mod tests { /// Everything the scalar builder can produce has to be flushed ahead of the next chunk. #[test] fn test_zeros_and_nulls_around_chunks_keep_their_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(I32, Nullable); let mut builder = ChildBuilder::with_capacity(&dtype, 0, BufferAllocatorRef::static_ref()); @@ -362,7 +366,7 @@ mod tests { #[test] fn test_finish_resets_the_builder() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ChildBuilder::with_capacity(&DType::from(I32), 0, BufferAllocatorRef::static_ref()); diff --git a/vortex-array/src/builders/decimal.rs b/vortex-array/src/builders/decimal.rs index 8da6a705dc8..2a664f17398 100644 --- a/vortex-array/src/builders/decimal.rs +++ b/vortex-array/src/builders/decimal.rs @@ -326,10 +326,12 @@ impl_from_buffer!(i256, I256); #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::BufferAllocatorRef; + use vortex_session::VortexSession; use crate::VortexSessionExecute; - use crate::array_session; use crate::assert_arrays_eq; use crate::builders::ArrayBuilder; use crate::builders::DecimalBuilder; @@ -339,6 +341,8 @@ mod tests { use crate::scalar::DecimalValue; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_mixed_extend() { let values = 42i8; @@ -358,22 +362,22 @@ mod tests { false.into(), BufferAllocatorRef::static_ref(), ); - i8s.append_to_builder(&mut i128s, &mut array_session().create_execution_ctx()) + i8s.append_to_builder(&mut i128s, &mut SESSION.create_execution_ctx()) .unwrap(); let i128s = i128s.finish(); for i in 0..i8s.len() { assert_eq!( - i8s.execute_scalar(i, &mut array_session().create_execution_ctx()) + i8s.execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), i128s - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap() ); } assert_eq!(i8s.len(), 42); assert_eq!(i128s.len(), 42); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for value in 0i8..42 { let expected = Scalar::decimal( DecimalValue::I8(value), @@ -393,7 +397,7 @@ mod tests { #[test] fn test_append_scalar() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Simply test that the builder accepts its own finish output via scalar. let mut builder = DecimalBuilder::new_in::( @@ -420,7 +424,7 @@ mod tests { ); for i in 0..array.len() { let scalar = array - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(); builder2.append_scalar(&scalar).unwrap(); } diff --git a/vortex-array/src/builders/dict/bytes.rs b/vortex-array/src/builders/dict/bytes.rs index 04b54e76c47..4614181a707 100644 --- a/vortex-array/src/builders/dict/bytes.rs +++ b/vortex-array/src/builders/dict/bytes.rs @@ -387,7 +387,7 @@ mod test { use crate::dtype::Nullability; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn encode_varbin() -> VortexResult<()> { diff --git a/vortex-array/src/builders/dict/primitive.rs b/vortex-array/src/builders/dict/primitive.rs index b4bffedc8f3..a3954dc0364 100644 --- a/vortex-array/src/builders/dict/primitive.rs +++ b/vortex-array/src/builders/dict/primitive.rs @@ -233,7 +233,7 @@ mod test { use crate::builders::dict::dict_encoder_in; use crate::builders::dict::primitive::PrimitiveArray; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn encode_primitive() { diff --git a/vortex-array/src/builders/extension.rs b/vortex-array/src/builders/extension.rs index 326664cfa16..d0edb237b99 100644 --- a/vortex-array/src/builders/extension.rs +++ b/vortex-array/src/builders/extension.rs @@ -140,9 +140,12 @@ impl ArrayBuilder for ExtensionBuilder { #[cfg(test)] mod tests { + use std::sync::LazyLock; + + use vortex_session::VortexSession; + use super::*; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; use crate::builders::ArrayBuilder; @@ -151,9 +154,11 @@ mod tests { use crate::extension::datetime::TimeUnit; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_append_scalar() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ext_dtype = Date::new(TimeUnit::Days, Nullability::Nullable).erased(); let mut builder = diff --git a/vortex-array/src/builders/fixed_size_list.rs b/vortex-array/src/builders/fixed_size_list.rs index f7932eb12e5..0584e138b5b 100644 --- a/vortex-array/src/builders/fixed_size_list.rs +++ b/vortex-array/src/builders/fixed_size_list.rs @@ -335,15 +335,16 @@ impl ArrayBuilder for FixedSizeListBuilder { #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use vortex_buffer::BufferAllocatorRef; use vortex_buffer::buffer; use vortex_error::VortexExpect; + use vortex_session::VortexSession; use super::FixedSizeListBuilder; use crate::IntoArray as _; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::fixed_size_list::FixedSizeListArrayExt; use crate::arrays::fixed_size_list::FixedSizeListArraySlotsExt; @@ -357,6 +358,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_empty() { let mut builder = FixedSizeListBuilder::with_capacity_in( @@ -411,7 +414,7 @@ mod tests { let fsl = builder.finish(); assert_eq!(fsl.len(), 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl_array = fsl.execute::(&mut ctx).unwrap(); assert_eq!(fsl_array.elements().len(), 6); assert_eq!(fsl_array.list_size(), 3); @@ -447,7 +450,7 @@ mod tests { let fsl = builder.finish(); assert_eq!(fsl.len(), 100); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl_array = fsl.execute::(&mut ctx).unwrap(); assert_eq!(fsl_array.list_size(), 0); // The elements array should be empty since list_size is 0. @@ -485,7 +488,7 @@ mod tests { let fsl = builder.finish(); assert_eq!(fsl.len(), 100); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl_array = fsl.execute::(&mut ctx).unwrap(); assert_eq!(fsl_array.list_size(), 0); assert_eq!(fsl_array.elements().len(), 0); @@ -527,7 +530,7 @@ mod tests { let fsl = builder.finish(); assert_eq!(fsl.len(), 5); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl_array = fsl.execute::(&mut ctx).unwrap(); assert_eq!(fsl_array.elements().len(), 10); let expected = FixedSizeListArray::new( @@ -554,7 +557,7 @@ mod tests { let fsl = builder.finish(); assert_eq!(fsl.len(), 0); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl_array = fsl.execute::(&mut ctx).unwrap(); assert_eq!(fsl_array.list_size(), 100000000); assert_eq!(fsl_array.elements().len(), 0); @@ -562,7 +565,7 @@ mod tests { #[test] fn test_nullable_lists_non_nullable_elements() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(DType::Primitive(I32, NonNullable)); let mut builder = FixedSizeListBuilder::with_capacity_in( Arc::clone(&dtype), @@ -669,7 +672,7 @@ mod tests { let fsl = builder.finish(); assert_eq!(fsl.len(), 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl_array = fsl.execute::(&mut ctx).unwrap(); assert_eq!(fsl_array.elements().len(), 6); let expected = FixedSizeListArray::new( @@ -705,7 +708,7 @@ mod tests { let fsl = builder.finish(); assert_eq!(fsl.len(), 5); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl_array = fsl.execute::(&mut ctx).unwrap(); assert_eq!(fsl_array.list_size(), 3); assert_eq!(fsl_array.elements().len(), 15); @@ -722,7 +725,7 @@ mod tests { #[test] fn test_append_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Elements must be nullable if we're going to append null lists let dtype: Arc = Arc::new(DType::Primitive(I32, Nullable)); let mut builder = FixedSizeListBuilder::with_capacity_in( @@ -757,7 +760,7 @@ mod tests { #[test] fn test_append_scalar_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Elements must be nullable if we're going to append null lists let dtype: Arc = Arc::new(DType::Primitive(I32, Nullable)); let mut builder = FixedSizeListBuilder::with_capacity_in( @@ -808,7 +811,7 @@ mod tests { let fsl = builder.finish(); assert_eq!(fsl.len(), 1000); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let fsl_array = fsl.execute::(&mut ctx).unwrap(); assert_eq!(fsl_array.list_size(), 0); assert_eq!(fsl_array.elements().len(), 0); @@ -846,7 +849,7 @@ mod tests { #[test] fn test_extend_from_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); // Create a source array. @@ -933,7 +936,7 @@ mod tests { #[test] fn test_extend_degenerate_arrays() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); // Create degenerate source arrays (size = 0). @@ -1015,7 +1018,7 @@ mod tests { #[test] fn test_extend_empty_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); // Create an empty source array. @@ -1065,7 +1068,7 @@ mod tests { #[test] fn test_mixed_operations() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Use nullable elements since we'll be appending nulls let dtype: Arc = Arc::new(DType::Primitive(I32, Nullable)); let mut builder = FixedSizeListBuilder::with_capacity_in( @@ -1180,7 +1183,7 @@ mod tests { #[test] fn test_append_scalar() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); let mut builder = FixedSizeListBuilder::with_capacity_in( Arc::clone(&dtype), @@ -1262,7 +1265,7 @@ mod tests { #[test] fn test_append_array_as_list() { let dtype: Arc = Arc::new(I32.into()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = FixedSizeListBuilder::with_capacity_in( Arc::clone(&dtype), 3, diff --git a/vortex-array/src/builders/list.rs b/vortex-array/src/builders/list.rs index 084d854dc48..7cd7c2ee868 100644 --- a/vortex-array/src/builders/list.rs +++ b/vortex-array/src/builders/list.rs @@ -421,6 +421,7 @@ impl ArrayBuilder for ListBuilder { #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use Nullability::NonNullable; use Nullability::Nullable; @@ -428,9 +429,9 @@ mod tests { use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; - use crate::array_session; use crate::arrays::ChunkedArray; use crate::arrays::ListViewArray; use crate::arrays::PrimitiveArray; @@ -451,6 +452,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_empty() { let mut builder = ListBuilder::::with_capacity_in( @@ -505,7 +508,7 @@ mod tests { let list = builder.finish(); assert_eq!(list.len(), 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list_array = list.execute::(&mut ctx).unwrap(); assert_eq!(list_array.list_elements_at(0, &mut ctx).unwrap().len(), 3); @@ -521,7 +524,7 @@ mod tests { #[test] fn test_append_empty_list() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); let mut builder = ListBuilder::::with_capacity_in( Arc::clone(&dtype), @@ -545,7 +548,7 @@ mod tests { assert_arrays_eq!( builder.finish(), expected, - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -589,7 +592,7 @@ mod tests { let list = builder.finish(); assert_eq!(list.len(), 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list_array = list.execute::(&mut ctx).unwrap(); assert_eq!(list_array.list_elements_at(0, &mut ctx).unwrap().len(), 3); @@ -613,7 +616,7 @@ mod tests { .into_array(); assert_eq!(list.len(), 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ListBuilder::::with_capacity_in( Arc::new(I32.into()), @@ -685,7 +688,7 @@ mod tests { /// non-`u64`) offset/size types. #[test] fn test_append_to_builder_any_list_builder() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::from_iter_opt_slow::( [Some(vec![0, 1, 2]), None, Some(vec![4, 5])], @@ -764,7 +767,7 @@ mod tests { #[test] fn test_append_list_arrays_grow_builder() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); // Enough lists to exceed the offsets capacity of a zero-capacity builder, so appending @@ -810,7 +813,7 @@ mod tests { #[test] fn test_append_listview_array_flattens_overlaps_and_skips_leading_elements() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); // Overlapping source, so not zero-copyable to a list: @@ -884,7 +887,7 @@ mod tests { #[test] pub fn test_array_with_gap() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let one_trailing_unused_element = ListArray::try_new( buffer![1, 2, 3, 4].into_array(), buffer![0, 3].into_array(), @@ -909,7 +912,7 @@ mod tests { DType::List(Arc::new(DType::Primitive(I32, NonNullable)), NonNullable), ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let canon_values = chunked_list .unwrap() .as_array() @@ -919,18 +922,18 @@ mod tests { assert_eq!( one_trailing_unused_element - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), canon_values - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() ); assert_eq!( second_array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), canon_values - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() ); } @@ -966,7 +969,7 @@ mod tests { let array = builder.finish_into_list(); assert_eq!(array.len(), 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Check actual values using scalar_at. @@ -1029,7 +1032,7 @@ mod tests { #[test] fn test_append_array_as_list() { let dtype: Arc = Arc::new(I32.into()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ListBuilder::::with_capacity_in( Arc::clone(&dtype), NonNullable, diff --git a/vortex-array/src/builders/listview.rs b/vortex-array/src/builders/listview.rs index 18312369fda..bafc1a4c575 100644 --- a/vortex-array/src/builders/listview.rs +++ b/vortex-array/src/builders/listview.rs @@ -659,16 +659,17 @@ fn extend_converted_sizes( #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use vortex_buffer::BufferAllocatorRef; use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::ListViewBuilder; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ConstantArray; use crate::arrays::ListArray; use crate::arrays::ListViewArray; @@ -684,6 +685,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_empty() { let mut builder = ListViewBuilder::::with_capacity_in( @@ -704,7 +707,7 @@ mod tests { #[test] fn test_basic_append_and_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); let mut builder = ListViewBuilder::::with_capacity_in( Arc::clone(&dtype), @@ -780,7 +783,7 @@ mod tests { #[test] fn test_different_offset_size_types() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test u64 offsets with u32 sizes. let dtype: Arc = Arc::new(I32.into()); let mut builder = ListViewBuilder::::with_capacity_in( @@ -863,7 +866,7 @@ mod tests { #[test] fn test_builder_trait_methods() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); let mut builder = ListViewBuilder::::with_capacity_in( Arc::clone(&dtype), @@ -928,7 +931,7 @@ mod tests { #[test] fn test_extend_from_array() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); // Create a source ListArray. @@ -1018,7 +1021,7 @@ mod tests { #[test] fn test_append_list_array_grows_builder() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); // Enough lists to exceed the offsets/sizes capacity of a zero-capacity builder, so @@ -1054,7 +1057,7 @@ mod tests { /// builder would materialize a copy per row. #[test] fn test_constant_list_append_keeps_one_copy_of_the_value() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let element_dtype: Arc = Arc::new(I32.into()); const ROWS: usize = 10_000; @@ -1091,7 +1094,7 @@ mod tests { /// middle of a list array leaves the elements on either side of it behind. #[test] fn test_append_listview_array_trims_unreferenced_elements() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); // Five lists of two elements each, of which we append only the middle three. @@ -1136,7 +1139,7 @@ mod tests { #[test] fn test_extend_from_array_overlapping_listview() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype: Arc = Arc::new(I32.into()); // Non-ZCTL source: @@ -1226,7 +1229,7 @@ mod tests { #[test] fn test_append_array_as_list() { let dtype: Arc = Arc::new(I32.into()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ListViewBuilder::::with_capacity_in( Arc::clone(&dtype), NonNullable, diff --git a/vortex-array/src/builders/mod.rs b/vortex-array/src/builders/mod.rs index d5744ad3df1..480c3f6a701 100644 --- a/vortex-array/src/builders/mod.rs +++ b/vortex-array/src/builders/mod.rs @@ -18,7 +18,8 @@ //! use vortex_array::builders::{ArrayBuilder, builder_with_capacity_in}; //! use vortex_array::dtype::{DType, Nullability}; //! use vortex_array::memory::BufferAllocatorRef; -//! use vortex_array::{VortexSessionExecute, array_session}; +//! use vortex_array::{VortexSessionExecute}; +//! use vortex_session::VortexSession; //! //! // Create a new builder for string data. //! let mut builder = builder_with_capacity_in(&DType::Utf8(Nullability::NonNullable), 4, BufferAllocatorRef::static_ref()); @@ -29,7 +30,7 @@ //! builder.append_scalar(&"d".into()).unwrap(); //! //! let strings = builder.finish(); -//! let mut ctx = array_session().create_execution_ctx(); +//! let mut ctx = VortexSession::empty().create_execution_ctx(); //! //! assert_eq!(strings.execute_scalar(0, &mut ctx).unwrap(), "a".into()); //! assert_eq!(strings.execute_scalar(1, &mut ctx).unwrap(), "b".into()); @@ -376,7 +377,8 @@ pub fn builder_with_capacity(dtype: &DType, capacity: usize) -> Box Box UninitRange<'_, T> { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexExpect; + use vortex_session::VortexSession; use super::*; use crate::VortexSessionExecute; - use crate::array_session; use crate::assert_arrays_eq; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// REGRESSION TEST: This test verifies that multiple sequential ranges have correct offsets. /// /// This would have caught the `Deref` bug where it always returned from the start of the /// buffer. #[test] fn test_multiple_uninit_ranges_correct_offsets() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = PrimitiveBuilder::::with_capacity_in( Nullability::NonNullable, 10, @@ -461,26 +465,26 @@ mod tests { // Check validity using scalar_at - nulls will return is_null() = true. assert!( !array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert!( array - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert!( !array - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert_arrays_eq!( array, PrimitiveArray::from_option_iter([Some(10i32), None, Some(30)]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -513,7 +517,7 @@ mod tests { /// This verifies the new simplified API without the redundant `len` parameter. #[test] fn test_copy_from_slice_with_offsets() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = PrimitiveBuilder::::with_capacity_in( Nullability::NonNullable, 10, @@ -588,13 +592,13 @@ mod tests { // Check validity - the first two should be valid (from append_value). assert!( !array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); // initial value 100 assert!( !array - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); // initial value 200 @@ -602,19 +606,19 @@ mod tests { // Check the range items with modified validity. assert!( !array - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); // range index 0 - set to valid assert!( array - .execute_scalar(3, &mut array_session().create_execution_ctx()) + .execute_scalar(3, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); // range index 1 - left as null assert!( !array - .execute_scalar(4, &mut array_session().create_execution_ctx()) + .execute_scalar(4, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); // range index 2 - set to valid @@ -694,7 +698,7 @@ mod tests { assert_arrays_eq!( array, PrimitiveArray::from_option_iter([Some(10i32), Some(20), None]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -734,7 +738,7 @@ mod tests { // values[2] might be any value since it's null. // Check validity - first two should be valid, third should be null. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!( array .validity() diff --git a/vortex-array/src/builders/struct_.rs b/vortex-array/src/builders/struct_.rs index 1ad0a97a87c..c437c2de024 100644 --- a/vortex-array/src/builders/struct_.rs +++ b/vortex-array/src/builders/struct_.rs @@ -231,11 +231,13 @@ impl ArrayBuilder for StructBuilder { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::BufferAllocatorRef; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::VarBinArray; use crate::assert_arrays_eq; @@ -249,6 +251,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_struct_builder() { let sdt = StructFields::new(["a", "b"].into(), vec![I32.into(), I32.into()]); @@ -269,7 +273,7 @@ mod tests { assert_eq!(struct_.dtype(), &dtype); assert_eq!( struct_ - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::struct_(dtype, vec![1i32.into(), 2i32.into()]) ); @@ -297,11 +301,11 @@ mod tests { assert_eq!(struct_.dtype(), &dtype); assert_eq!( struct_ - .valid_count(&mut array_session().create_execution_ctx()) + .valid_count(&mut SESSION.create_execution_ctx()) .unwrap(), 1 ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( struct_.execute_scalar(0, &mut ctx).unwrap(), Scalar::struct_(dtype.clone(), vec![1i32.into(), 2i32.into()]) @@ -318,7 +322,7 @@ mod tests { #[test] fn test_append_scalar() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); use crate::scalar::Scalar; let dtype = DType::Struct( diff --git a/vortex-array/src/builders/tests.rs b/vortex-array/src/builders/tests.rs index d3bb402866d..0271837c8e5 100644 --- a/vortex-array/src/builders/tests.rs +++ b/vortex-array/src/builders/tests.rs @@ -4,6 +4,7 @@ use std::alloc::Layout; use std::ptr::NonNull; use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; @@ -17,6 +18,7 @@ use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_panic; +use vortex_session::VortexSession; use crate::ArrayRef; use crate::Canonical; @@ -24,7 +26,6 @@ use crate::ExecutionCtx; use crate::RecursiveCanonical; use crate::VortexSessionExecute; use crate::array::IntoArray; -use crate::array_session; use crate::arrays::Chunked; use crate::arrays::ChunkedArray; use crate::arrays::Constant; @@ -63,6 +64,8 @@ use crate::extension::datetime::Timestamp; use crate::scalar::Scalar; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[derive(Debug)] struct CountingAllocator { allocations: Arc, @@ -243,10 +246,10 @@ fn test_append_zeros_matches_default_value(#[case] dtype: DType) { // Compare each element. for i in 0..num_elements { let scalar_zeros = array_zeros - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(); let scalar_manual = array_manual - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!(scalar_zeros.dtype(), &dtype); @@ -349,7 +352,7 @@ fn test_append_defaults_behavior(#[case] dtype: DType, #[case] should_be_null: b for i in 0..3 { let scalar = array - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(); if should_be_null { assert!(scalar.is_null(), "Element at index {} should be null", i); @@ -418,7 +421,7 @@ fn compare_to_canonical_methods( #[test] fn test_to_canonical_bool() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Bool(Nullability::NonNullable); let expected = [true, false, true, false, true].map(Scalar::from).to_vec(); compare_to_canonical_methods(&dtype, &expected, &mut ctx, |builder| { @@ -431,7 +434,7 @@ fn test_to_canonical_bool() { #[test] fn test_to_canonical_bool_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Bool(Nullability::Nullable); let expected = [ Some(true), @@ -454,7 +457,7 @@ fn test_to_canonical_bool_nullable() { #[test] fn test_to_canonical_i32() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let expected = [0i32, 1, 2, 3, 4].map(Scalar::from).to_vec(); compare_to_canonical_methods(&dtype, &expected, &mut ctx, |builder| { @@ -467,7 +470,7 @@ fn test_to_canonical_i32() { #[test] fn test_to_canonical_i32_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I32, Nullability::Nullable); let expected = [Some(0i32), Some(1), Some(2), Some(3), Some(4), None] .map(Scalar::from) @@ -483,7 +486,7 @@ fn test_to_canonical_i32_nullable() { #[test] fn test_to_canonical_f64() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F64, Nullability::NonNullable); let expected = [0.0f64, 1.0, 2.0, 3.0, 4.0].map(Scalar::from).to_vec(); compare_to_canonical_methods(&dtype, &expected, &mut ctx, |builder| { @@ -496,7 +499,7 @@ fn test_to_canonical_f64() { #[test] fn test_to_canonical_utf8() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Utf8(Nullability::NonNullable); let expected = ["hello", "world", "test", "data", "vortex"] .map(Scalar::from) @@ -512,7 +515,7 @@ fn test_to_canonical_utf8() { #[test] fn test_to_canonical_utf8_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Utf8(Nullability::Nullable); let expected = [Some("hello"), Some("world"), Some("test"), None] .map(|value| { @@ -534,7 +537,7 @@ fn test_to_canonical_utf8_nullable() { #[test] fn test_to_canonical_binary() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Binary(Nullability::NonNullable); let expected = [b"hello", b"world", b"vortx", b"bytes", b"tests"] .map(|value| Scalar::binary(value.to_vec(), Nullability::NonNullable)) @@ -550,7 +553,7 @@ fn test_to_canonical_binary() { #[test] fn test_to_canonical_struct() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Struct( StructFields::from_iter([ ("a", DType::Primitive(PType::I32, Nullability::NonNullable)), @@ -570,7 +573,7 @@ fn test_to_canonical_struct() { #[test] fn test_to_canonical_extension() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Extension(Timestamp::new(TimeUnit::Milliseconds, Nullability::NonNullable).erased()); let expected = [0i64, 1, 2, 3, 4] @@ -596,7 +599,7 @@ fn test_to_canonical_extension() { #[test] fn test_to_canonical_null() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Null; let expected = vec![Scalar::null(DType::Null); 5]; compare_to_canonical_methods(&dtype, &expected, &mut ctx, |builder| { @@ -606,7 +609,7 @@ fn test_to_canonical_null() { #[test] fn test_to_canonical_decimal() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Decimal(DecimalDType::new(10, 2), Nullability::NonNullable); let expected = vec![ Scalar::decimal( @@ -626,7 +629,7 @@ fn test_to_canonical_decimal() { #[test] fn test_to_canonical_i8() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I8, Nullability::NonNullable); let expected = [0i8, 1, 2, 3, 4].map(Scalar::from).to_vec(); compare_to_canonical_methods(&dtype, &expected, &mut ctx, |builder| { @@ -639,7 +642,7 @@ fn test_to_canonical_i8() { #[test] fn test_to_canonical_u64() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::U64, Nullability::NonNullable); let expected = [0u64, 1, 2, 3, 4].map(Scalar::from).to_vec(); compare_to_canonical_methods(&dtype, &expected, &mut ctx, |builder| { @@ -652,7 +655,7 @@ fn test_to_canonical_u64() { #[test] fn test_to_canonical_f32() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::F32, Nullability::NonNullable); let expected = [0.0f32, 1.0, 2.0, 3.0, 4.0].map(Scalar::from).to_vec(); compare_to_canonical_methods(&dtype, &expected, &mut ctx, |builder| { @@ -764,7 +767,7 @@ fn test_append_scalar_comprehensive(#[case] dtype: DType) { // Verify each scalar matches. for (i, expected_scalar) in scalars.iter().enumerate() { let actual_scalar = array - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(); assert_scalars_equal(&actual_scalar, expected_scalar, &dtype, i); } @@ -772,7 +775,7 @@ fn test_append_scalar_comprehensive(#[case] dtype: DType) { // If nullable, verify the last element is null. if dtype.is_nullable() { let null_scalar = array - .execute_scalar(num_elements, &mut array_session().create_execution_ctx()) + .execute_scalar(num_elements, &mut SESSION.create_execution_ctx()) .unwrap(); assert!( null_scalar.is_null(), @@ -912,31 +915,31 @@ fn test_append_scalar_mixed_nulls(#[case] dtype: DType) { // Check the pattern. assert!( !array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert!( array - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert!( !array - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert!( array - .execute_scalar(3, &mut array_session().create_execution_ctx()) + .execute_scalar(3, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); assert!( !array - .execute_scalar(4, &mut array_session().create_execution_ctx()) + .execute_scalar(4, &mut SESSION.create_execution_ctx()) .unwrap() .is_null() ); @@ -944,7 +947,7 @@ fn test_append_scalar_mixed_nulls(#[case] dtype: DType) { // Verify non-null values match. assert_scalars_equal( &array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), &test_scalars[0], &dtype, @@ -952,7 +955,7 @@ fn test_append_scalar_mixed_nulls(#[case] dtype: DType) { ); assert_scalars_equal( &array - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap(), &test_scalars[1], &dtype, @@ -960,7 +963,7 @@ fn test_append_scalar_mixed_nulls(#[case] dtype: DType) { ); assert_scalars_equal( &array - .execute_scalar(4, &mut array_session().create_execution_ctx()) + .execute_scalar(4, &mut SESSION.create_execution_ctx()) .unwrap(), &test_scalars[2], &dtype, @@ -1028,7 +1031,7 @@ fn test_append_scalar_repeated_same_instance() { // All values should be 42. for i in 0..5 { let actual = array - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!( actual.as_primitive().typed_value::(), @@ -1057,7 +1060,7 @@ fn test_append_scalar_repeated_same_instance() { (0..CHUNK_LEN as u64).collect::>().into_array(), Buffer::full(1u64, CHUNK_LEN).into_array(), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .into_array(), |array: &ArrayRef| array.as_::().elements().clone() @@ -1088,7 +1091,7 @@ fn test_children_are_not_canonicalized( #[case] array: ArrayRef, #[case] child_of: fn(&ArrayRef) -> ArrayRef, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = builder_with_capacity_in(array.dtype(), 0, BufferAllocatorRef::static_ref()); array.append_to_builder(builder.as_mut(), &mut ctx)?; @@ -1125,7 +1128,7 @@ fn test_children_are_not_canonicalized( /// scalars instead is what asks the builder to copy the values into one canonical child. #[test] fn test_children_are_chunked_on_the_boundaries_they_are_appended_on() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = ConstantArray::new(1i32, 2).into_array(); let array = FixedSizeListArray::new(elements, 2, Validity::NonNullable, 1).into_array(); @@ -1176,7 +1179,7 @@ fn test_children_are_chunked_on_the_boundaries_they_are_appended_on() -> VortexR /// A builder that mixes appended arrays with scalar appends must keep the two in order. #[test] fn test_struct_builder_interleaves_arrays_and_scalars() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = StructArray::try_from_iter([("a", constant_i32())])?.into_array(); let scalar = Scalar::struct_( @@ -1208,7 +1211,7 @@ const CHUNK_LEN: usize = 64; /// array's validity is kept as it arrived rather than executed into a mask and copied bit by bit. #[test] fn test_appended_validity_is_not_materialized() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = StructArray::try_from_iter_with_validity( [("a", iota(CHUNK_LEN))], @@ -1250,7 +1253,7 @@ fn constant_i32() -> ArrayRef { /// Two lists of [`CHUNK_LEN`] elements each, so that appending them chunks the elements. fn two_lists_of_chunk_len() -> ListViewArray { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); ListViewArray::new( iota(2 * CHUNK_LEN), u64s([0, CHUNK_LEN]), @@ -1289,14 +1292,14 @@ fn u64s(values: impl IntoIterator) -> ArrayRef { iota(2 * CHUNK_LEN), u64s([0, CHUNK_LEN, 2 * CHUNK_LEN]), Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .into_array() )] fn test_list_offsets_are_rebased_across_element_chunks( #[case] lists: ArrayRef, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = builder_with_capacity_in( &DType::List( @@ -1332,7 +1335,7 @@ fn test_list_offsets_are_rebased_across_element_chunks( /// elements builder through `append_array_as_list` rather than a bulk append. #[test] fn test_list_builder_offsets_are_rebased_across_element_chunks() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let mut builder = ListBuilder::::with_capacity_in( @@ -1390,7 +1393,7 @@ fn test_validity_survives_chunked_children( #[case] array: ArrayRef, #[case] child_of: fn(&ArrayRef) -> ArrayRef, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = builder_with_capacity_in(array.dtype(), 0, BufferAllocatorRef::static_ref()); array.append_to_builder(builder.as_mut(), &mut ctx)?; @@ -1428,7 +1431,7 @@ fn test_validity_survives_chunked_children( /// Consumers that genuinely need a fully-decoded tree ask for it, and must still get one. #[test] fn test_chunked_children_canonicalize_recursively() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = StructArray::try_from_iter([("a", constant_i32())])?.into_array(); let mut builder = builder_with_capacity_in(array.dtype(), 0, BufferAllocatorRef::static_ref()); diff --git a/vortex-array/src/builders/validity.rs b/vortex-array/src/builders/validity.rs index 7b575a01196..358473b603a 100644 --- a/vortex-array/src/builders/validity.rs +++ b/vortex-array/src/builders/validity.rs @@ -133,18 +133,22 @@ impl ValidityBuilder { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use super::ValidityBuilder; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Chunked; use crate::dtype::Nullability::NonNullable; use crate::dtype::Nullability::Nullable; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// An arbitrary run length. `ValidityBuilder` treats no length specially, so the tests only /// need a length long enough to tell runs apart. const RUN_LEN: usize = 64; @@ -171,7 +175,7 @@ mod tests { ); assert_eq!( Validity::Array(array) - .execute_mask(2 * RUN_LEN, &mut array_session().create_execution_ctx()) + .execute_mask(2 * RUN_LEN, &mut SESSION.create_execution_ctx()) .unwrap(), Mask::from_iter((0..2 * RUN_LEN).map(|i| i % 2 == 0)), ); @@ -211,7 +215,7 @@ mod tests { /// Bits and runs interleave, and have to come back out in the order they went in. #[test] fn test_bits_and_runs_keep_their_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ValidityBuilder::new(0, BufferAllocatorRef::static_ref()); builder.append_n_nulls(1); diff --git a/vortex-array/src/builders/varbinview.rs b/vortex-array/src/builders/varbinview.rs index b0b24f8c443..8751802aeb0 100644 --- a/vortex-array/src/builders/varbinview.rs +++ b/vortex-array/src/builders/varbinview.rs @@ -1400,14 +1400,16 @@ impl RewritingViewAdjustment { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::BufferAllocatorRef; use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::assert_arrays_eq; use crate::builders::ArrayBuilder; use crate::builders::VarBinViewBuilder; @@ -1416,6 +1418,8 @@ mod tests { use crate::dtype::Nullability; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// A long-enough value that a view over it must reference a data buffer. const LONG: &str = "a value that is far too long to inline"; @@ -1423,7 +1427,7 @@ mod tests { /// and the append composes with staged in-progress bytes on either side. #[test] fn test_append_buffer_with_lengths() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinViewBuilder::with_capacity_in( DType::Utf8(Nullability::Nullable), 8, @@ -1457,7 +1461,7 @@ mod tests { /// Offsets need not start at zero: only the referenced range of the heap is adopted. #[test] fn test_append_buffer_with_offsets() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinViewBuilder::with_capacity_in( DType::Utf8(Nullability::Nullable), 8, @@ -1494,7 +1498,7 @@ mod tests { /// never reference it, so an under-utilized heap is rewritten to just the referencing values. #[test] fn test_append_buffer_with_lengths_compacts_underutilized_heap() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinViewBuilder::with_compaction_in( DType::Utf8(Nullability::Nullable), 4, @@ -1526,7 +1530,7 @@ mod tests { /// bytes or producing views that reference them. #[test] fn test_append_buffer_with_lengths_compaction_skips_null_bytes() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinViewBuilder::with_compaction_in( DType::Utf8(Nullability::Nullable), 2, @@ -1575,7 +1579,7 @@ mod tests { /// resolve their index. #[test] fn test_append_views_gathered() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dictionary = >::from_iter([ Some("tiny"), Some(LONG), @@ -1621,7 +1625,7 @@ mod tests { fn test_append_views_scattered() { use crate::arrays::varbinview::build_views::BinaryView; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patch_values = >::from_iter([Some(LONG), Some("tiny")]); let mut buffers = patch_values @@ -1670,7 +1674,7 @@ mod tests { const DEAD: &str = "a dead value nobody gathers, far too long to inline"; const OTHER: &str = "another value far too long to inline"; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dictionary = >::from_iter([Some(LONG), Some(DEAD), Some(OTHER)]); assert_eq!(dictionary.data_buffers().len(), 1); @@ -1718,7 +1722,7 @@ mod tests { fn test_append_views_gathered_slices_contiguous_range() { const TAIL: &str = "the referenced tail value, too long to inline"; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dictionary = >::from_iter([Some(LONG), Some(TAIL)]); let heap = dictionary.data_buffers()[0].as_host().clone(); @@ -1752,7 +1756,7 @@ mod tests { fn test_append_views_gathered_keeps_utilized_buffer() { const SHORTER: &str = "a shorter long value"; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dictionary = >::from_iter([Some(LONG), Some(SHORTER)]); let heap = dictionary.data_buffers()[0].as_host().clone(); @@ -1783,7 +1787,7 @@ mod tests { /// buffers — and must never resolve a code. #[test] fn test_append_views_gathered_all_null_drops_buffers() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dictionary = >::from_iter([Some(LONG)]); let buffers = dictionary .data_buffers() @@ -1814,7 +1818,7 @@ mod tests { /// A fully-inlined heap has zero utilization; a compacting builder must not retain it at all. #[test] fn test_append_buffer_with_lengths_drops_fully_inlined_heap() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinViewBuilder::with_compaction_in( DType::Utf8(Nullability::Nullable), 4, @@ -1841,7 +1845,7 @@ mod tests { #[test] fn test_utf8_builder() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinViewBuilder::with_capacity_in( DType::Utf8(Nullability::Nullable), 10, @@ -1892,7 +1896,7 @@ mod tests { #[test] fn test_utf8_builder_with_extend() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = { let mut builder = VarBinViewBuilder::with_capacity_in( DType::Utf8(Nullability::Nullable), @@ -1964,7 +1968,7 @@ mod tests { BufferAllocatorRef::statically_allocated(), ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); array.append_to_builder(&mut builder, &mut ctx)?; assert_eq!(builder.completed_block_count(), 1); @@ -2015,7 +2019,7 @@ mod tests { #[test] fn test_append_scalar() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); use crate::scalar::Scalar; // Test with Utf8 builder. @@ -2118,7 +2122,7 @@ mod tests { // Verify the value was stored correctly let retrieved = array - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .as_binary() .value() diff --git a/vortex-array/src/canonical.rs b/vortex-array/src/canonical.rs index eb92d6300b8..4b437da716a 100644 --- a/vortex-array/src/canonical.rs +++ b/vortex-array/src/canonical.rs @@ -1223,7 +1223,7 @@ mod tests { use crate::scalar::Scalar; /// A shared session for these canonical tests, used to create execution contexts. - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); fn variant_core_storage(len: usize) -> ArrayRef { ConstantArray::new( diff --git a/vortex-array/src/compute/conformance/cast.rs b/vortex-array/src/compute/conformance/cast.rs index aee3b0f86c5..32d194edf41 100644 --- a/vortex-array/src/compute/conformance/cast.rs +++ b/vortex-array/src/compute/conformance/cast.rs @@ -343,7 +343,6 @@ mod tests { use super::*; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ListArray; use crate::arrays::NullArray; @@ -354,7 +353,7 @@ mod tests { use crate::dtype::FieldNames; use crate::dtype::Nullability; - static SESSION: LazyLock = LazyLock::new(array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_cast_conformance_u32() { diff --git a/vortex-array/src/compute/conformance/search_sorted.rs b/vortex-array/src/compute/conformance/search_sorted.rs index fc32af9ddbb..ad70afbb973 100644 --- a/vortex-array/src/compute/conformance/search_sorted.rs +++ b/vortex-array/src/compute/conformance/search_sorted.rs @@ -8,11 +8,11 @@ pub use rstest_reuse; use rstest_reuse::template; use vortex_buffer::Buffer; use vortex_buffer::buffer; +use vortex_session::VortexSession; use crate::ArrayRef; use crate::VortexSessionExecute; use crate::array::IntoArray; -use crate::array_session; use crate::arrays::PrimitiveArray; use crate::patches::Patches; use crate::validity::Validity; @@ -22,7 +22,7 @@ pub fn all_null() -> ArrayRef { } pub fn sparse_high_null_fill() -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); PrimitiveArray::new(buffer![0; 20], Validity::AllInvalid) .patch( &Patches::new( @@ -41,7 +41,7 @@ pub fn sparse_high_null_fill() -> ArrayRef { } pub fn sparse_high_non_null_fill() -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); PrimitiveArray::new(buffer![22; 20], Validity::NonNullable) .patch( &Patches::new( @@ -60,7 +60,7 @@ pub fn sparse_high_non_null_fill() -> ArrayRef { } pub fn sparse_low() -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); PrimitiveArray::new(buffer![60; 20], Validity::NonNullable) .patch( &Patches::new( @@ -79,7 +79,7 @@ pub fn sparse_low() -> ArrayRef { } pub fn sparse_low_high() -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); PrimitiveArray::new(buffer![30; 20], Validity::NonNullable) .patch( &Patches::new( @@ -98,7 +98,7 @@ pub fn sparse_low_high() -> ArrayRef { } pub fn sparse_edge_patch_high() -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); PrimitiveArray::new(buffer![33; 20], Validity::NonNullable) .patch( &Patches::new( @@ -117,7 +117,7 @@ pub fn sparse_edge_patch_high() -> ArrayRef { } pub fn sparse_edge_patch_low() -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); PrimitiveArray::new(buffer![22; 20], Validity::NonNullable) .patch( &Patches::new( diff --git a/vortex-array/src/display/mod.rs b/vortex-array/src/display/mod.rs index 3d247f3949f..cdaa7d3c5c9 100644 --- a/vortex-array/src/display/mod.rs +++ b/vortex-array/src/display/mod.rs @@ -31,8 +31,9 @@ pub enum DisplayOptions { /// Only the top-level encoding id and limited metadata: `vortex.primitive(i16, len=5)`. /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -46,8 +47,9 @@ pub enum DisplayOptions { /// Only the logical values of the array: `[0i16, 1i16, 2i16, 3i16, 4i16]`. /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -67,8 +69,9 @@ pub enum DisplayOptions { /// With buffers, metadata, and stats: /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -99,8 +102,9 @@ pub enum DisplayOptions { /// With metadata and stats but no buffers: /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -128,8 +132,9 @@ pub enum DisplayOptions { /// With metadata and buffers but no stats: /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -160,8 +165,9 @@ pub enum DisplayOptions { /// With buffers and stats but no metadata: /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -188,8 +194,9 @@ pub enum DisplayOptions { /// With just buffers: /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -216,8 +223,9 @@ pub enum DisplayOptions { /// With just metadata: /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -245,8 +253,9 @@ pub enum DisplayOptions { /// With just stats: /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -270,8 +279,9 @@ pub enum DisplayOptions { /// With neither buffers, metadata, stats, nor values: /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; @@ -301,8 +311,9 @@ pub enum DisplayOptions { /// For regular arrays, displays a single column with values. /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::display::DisplayOptions; /// # use vortex_array::arrays::StructArray; /// # use vortex_array::IntoArray; @@ -391,8 +402,9 @@ impl ArrayRef { /// # Examples /// /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # use vortex_array::IntoArray; /// # use vortex_buffer::buffer; /// let array = buffer![0_i16, 1, 2, 3, 4].into_array(); @@ -542,8 +554,9 @@ impl ArrayRef { /// /// # Examples /// ``` + /// # use vortex_session::VortexSession; /// # use vortex_array::VortexSessionExecute; - /// # let ctx = vortex_array::array_session().create_execution_ctx(); + /// # let ctx = VortexSession::empty().create_execution_ctx(); /// # #[cfg(feature = "table-display")] /// # { /// # use vortex_array::arrays::StructArray; @@ -712,12 +725,14 @@ impl ArrayRef { #[cfg(test)] mod test { + use std::sync::LazyLock; + use vortex_buffer::Buffer; use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray as _; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ListArray; use crate::arrays::PrimitiveArray; @@ -726,9 +741,11 @@ mod test { use crate::dtype::FieldNames; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_primitive() { - let ctx = array_session().create_execution_ctx(); + let ctx = SESSION.create_execution_ctx(); let x = Buffer::::empty().into_array(); assert_eq!(x.display_values(&ctx).to_string(), "[]"); @@ -751,7 +768,7 @@ mod test { #[test] fn test_empty_struct() { - let ctx = array_session().create_execution_ctx(); + let ctx = SESSION.create_execution_ctx(); let s = StructArray::try_new( FieldNames::empty(), vec![], @@ -765,7 +782,7 @@ mod test { #[test] fn test_simple_struct() { - let ctx = array_session().create_execution_ctx(); + let ctx = SESSION.create_execution_ctx(); let s = StructArray::from_fields(&[ ("x", buffer![1, 2, 3, 4].into_array()), ("y", buffer![-1, -2, -3, -4].into_array()), @@ -780,7 +797,7 @@ mod test { #[test] fn test_list() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let x = ListArray::try_new( buffer![1, 2, 3, 4].into_array(), buffer![0, 0, 1, 1, 2, 4].into_array(), @@ -805,7 +822,7 @@ mod test { #[test] fn test_table_display_primitive() { - let ctx = array_session().create_execution_ctx(); + let ctx = SESSION.create_execution_ctx(); use crate::display::DisplayOptions; let array = buffer![1, 2, 3, 4].into_array(); @@ -828,7 +845,7 @@ mod test { #[test] fn test_table_display() { - let ctx = array_session().create_execution_ctx(); + let ctx = SESSION.create_execution_ctx(); use crate::display::DisplayOptions; let array = diff --git a/vortex-array/src/dtype/mod.rs b/vortex-array/src/dtype/mod.rs index f568495cd93..6d74b928d3e 100644 --- a/vortex-array/src/dtype/mod.rs +++ b/vortex-array/src/dtype/mod.rs @@ -217,5 +217,5 @@ mod test { use vortex_session::VortexSession; - pub(crate) static SESSION: LazyLock = LazyLock::new(crate::array_session); + pub(crate) static SESSION: LazyLock = LazyLock::new(VortexSession::empty); } diff --git a/vortex-array/src/dtype/serde/proto.rs b/vortex-array/src/dtype/serde/proto.rs index 50367a90276..99a3fd7801f 100644 --- a/vortex-array/src/dtype/serde/proto.rs +++ b/vortex-array/src/dtype/serde/proto.rs @@ -286,8 +286,9 @@ impl TryFrom<&pb::FieldPath> for FieldPath { mod tests { use std::sync::Arc; + use vortex_session::VortexSession; + use super::*; - use crate::array_session; use crate::dtype::DType; use crate::dtype::DecimalDType; use crate::dtype::Field; @@ -693,7 +694,7 @@ mod tests { #[test] fn test_unknown_extension_allow_unknown() { - let session = array_session(); + let session = VortexSession::empty(); session.allow_unknown(); let proto = pb::DType { dtype_type: Some(DtypeType::Extension(Box::new(pb::Extension { diff --git a/vortex-array/src/expr/exprs.rs b/vortex-array/src/expr/exprs.rs index d77a3472d30..8634ae901b3 100644 --- a/vortex-array/src/expr/exprs.rs +++ b/vortex-array/src/expr/exprs.rs @@ -336,13 +336,14 @@ pub fn bound_binary( /// # use vortex_array::arrays::{BoolArray, PrimitiveArray}; /// # use vortex_array::arrays::bool::BoolArrayExt; /// # use vortex_array::IntoArray; -/// # use vortex_array::{VortexSessionExecute, array_session}; +/// # use vortex_array::{VortexSessionExecute}; +/// # use vortex_session::VortexSession; /// # use vortex_array::validity::Validity; /// # use vortex_buffer::buffer; /// # use vortex_array::expr::{eq, root, lit}; /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable); /// let result = xs.into_array().apply(&eq(root(), lit(3))).unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// /// assert_eq!( /// result.execute::(&mut ctx).unwrap().to_bit_buffer(), @@ -368,13 +369,14 @@ pub fn bound_eq(lhs: BoundExpression, rhs: BoundExpression) -> BoundExpression { /// # use vortex_array::arrays::{BoolArray, PrimitiveArray}; /// # use vortex_array::arrays::bool::BoolArrayExt; /// # use vortex_array::IntoArray; -/// # use vortex_array::{VortexSessionExecute, array_session}; +/// # use vortex_array::{VortexSessionExecute}; +/// # use vortex_session::VortexSession; /// # use vortex_array::validity::Validity; /// # use vortex_buffer::buffer; /// # use vortex_array::expr::{root, lit, not_eq}; /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable); /// let result = xs.into_array().apply(¬_eq(root(), lit(3))).unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// /// assert_eq!( /// result.execute::(&mut ctx).unwrap().to_bit_buffer(), @@ -400,13 +402,14 @@ pub fn bound_not_eq(lhs: BoundExpression, rhs: BoundExpression) -> BoundExpressi /// # use vortex_array::arrays::{BoolArray, PrimitiveArray }; /// # use vortex_array::arrays::bool::BoolArrayExt; /// # use vortex_array::IntoArray; -/// # use vortex_array::{VortexSessionExecute, array_session}; +/// # use vortex_array::{VortexSessionExecute}; +/// # use vortex_session::VortexSession; /// # use vortex_array::validity::Validity; /// # use vortex_buffer::buffer; /// # use vortex_array::expr::{gt_eq, root, lit}; /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable); /// let result = xs.into_array().apply(>_eq(root(), lit(3))).unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// /// assert_eq!( /// result.execute::(&mut ctx).unwrap().to_bit_buffer(), @@ -432,13 +435,14 @@ pub fn bound_gt_eq(lhs: BoundExpression, rhs: BoundExpression) -> BoundExpressio /// # use vortex_array::arrays::{BoolArray, PrimitiveArray }; /// # use vortex_array::arrays::bool::BoolArrayExt; /// # use vortex_array::IntoArray; -/// # use vortex_array::{VortexSessionExecute, array_session}; +/// # use vortex_array::{VortexSessionExecute}; +/// # use vortex_session::VortexSession; /// # use vortex_array::validity::Validity; /// # use vortex_buffer::buffer; /// # use vortex_array::expr::{gt, root, lit}; /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable); /// let result = xs.into_array().apply(>(root(), lit(2))).unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// /// assert_eq!( /// result.execute::(&mut ctx).unwrap().to_bit_buffer(), @@ -464,13 +468,14 @@ pub fn bound_gt(lhs: BoundExpression, rhs: BoundExpression) -> BoundExpression { /// # use vortex_array::arrays::{BoolArray, PrimitiveArray }; /// # use vortex_array::arrays::bool::BoolArrayExt; /// # use vortex_array::IntoArray; -/// # use vortex_array::{VortexSessionExecute, array_session}; +/// # use vortex_array::{VortexSessionExecute}; +/// # use vortex_session::VortexSession; /// # use vortex_array::validity::Validity; /// # use vortex_buffer::buffer; /// # use vortex_array::expr::{root, lit, lt_eq}; /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable); /// let result = xs.into_array().apply(<_eq(root(), lit(2))).unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// /// assert_eq!( /// result.execute::(&mut ctx).unwrap().to_bit_buffer(), @@ -496,13 +501,14 @@ pub fn bound_lt_eq(lhs: BoundExpression, rhs: BoundExpression) -> BoundExpressio /// # use vortex_array::arrays::{BoolArray, PrimitiveArray }; /// # use vortex_array::arrays::bool::BoolArrayExt; /// # use vortex_array::IntoArray; -/// # use vortex_array::{VortexSessionExecute, array_session}; +/// # use vortex_array::{VortexSessionExecute}; +/// # use vortex_session::VortexSession; /// # use vortex_array::validity::Validity; /// # use vortex_buffer::buffer; /// # use vortex_array::expr::{root, lit, lt}; /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable); /// let result = xs.into_array().apply(<(root(), lit(3))).unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// /// assert_eq!( /// result.execute::(&mut ctx).unwrap().to_bit_buffer(), @@ -528,11 +534,12 @@ pub fn bound_lt(lhs: BoundExpression, rhs: BoundExpression) -> BoundExpression { /// # use vortex_array::arrays::BoolArray; /// # use vortex_array::arrays::bool::BoolArrayExt; /// # use vortex_array::IntoArray; -/// # use vortex_array::{VortexSessionExecute, array_session}; +/// # use vortex_array::{VortexSessionExecute}; +/// # use vortex_session::VortexSession; /// # use vortex_array::expr::{root, lit, or}; /// let xs = BoolArray::from_iter(vec![true, false, true]); /// let result = xs.into_array().apply(&or(root(), lit(false))).unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// /// assert_eq!( /// result.execute::(&mut ctx).unwrap().to_bit_buffer(), @@ -579,11 +586,12 @@ where /// # use vortex_array::arrays::BoolArray; /// # use vortex_array::arrays::bool::BoolArrayExt; /// # use vortex_array::IntoArray; -/// # use vortex_array::{VortexSessionExecute, array_session}; +/// # use vortex_array::{VortexSessionExecute}; +/// # use vortex_session::VortexSession; /// # use vortex_array::expr::{and, root, lit}; /// let xs = BoolArray::from_iter(vec![true, false, true]).into_array(); /// let result = xs.apply(&and(root(), lit(true))).unwrap(); -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// /// assert_eq!( /// result.execute::(&mut ctx).unwrap().to_bit_buffer(), @@ -630,13 +638,14 @@ where /// # use vortex_array::IntoArray; /// # use vortex_array::arrays::PrimitiveArray; /// # use vortex_array::builtins::ArrayBuiltins; -/// # use vortex_array::{VortexSessionExecute, array_session}; +/// # use vortex_array::{VortexSessionExecute}; +/// # use vortex_session::VortexSession; /// # use vortex_buffer::buffer; /// # use vortex_array::expr::{checked_add, lit, root}; /// let xs = buffer![1, 2, 3].into_array(); /// let result = xs.apply(&checked_add(root(), lit(5))).unwrap(); /// -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// let result = result.execute::(&mut ctx).unwrap(); /// assert_eq!(result.as_slice::(), [6, 7, 8]); /// ``` diff --git a/vortex-array/src/expr/lambda/tests.rs b/vortex-array/src/expr/lambda/tests.rs index d1f4f076fe9..d09592bdf11 100644 --- a/vortex-array/src/expr/lambda/tests.rs +++ b/vortex-array/src/expr/lambda/tests.rs @@ -4,19 +4,20 @@ use std::fmt; use std::fmt::Display; use std::fmt::Formatter; +use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_session::VortexSession; use vortex_session::registry::CachedId; use crate::ArrayRef; use crate::ExecutionCtx; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::StructArray; use crate::assert_arrays_eq; @@ -45,6 +46,8 @@ use crate::scalar_fn::ScalarFnVTable; use crate::scalar_fn::ScalarFnVTableExt; use crate::scalar_fn::internal::row_count::RowCount; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// `apply(value, lambda)` gives the lambda's one parameter the value of `value`, row by row: the /// smallest function that takes a lambda. #[derive(Clone)] @@ -145,7 +148,7 @@ fn rows() -> VortexResult { } fn assert_applies(expr: &Expression, expected: ArrayRef) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(rows()?.apply(expr)?, expected, &mut ctx); Ok(()) } @@ -309,7 +312,7 @@ fn evaluate_runs_the_bound_body() -> VortexResult<()> { let lambda = Lambda::new(["x"], checked_add(var("x"), lit(1_i32)))?.bind(&[i32_().as_nullable()])?; let x = PrimitiveArray::from_option_iter([Some(1_i32), None]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( lambda.evaluate(vec![x], 2)?, PrimitiveArray::from_option_iter([Some(2_i32), None]).into_array(), diff --git a/vortex-array/src/expr/optimize.rs b/vortex-array/src/expr/optimize.rs index ecf7e3d21e7..fdb6e0cbcfc 100644 --- a/vortex-array/src/expr/optimize.rs +++ b/vortex-array/src/expr/optimize.rs @@ -122,14 +122,16 @@ impl BoundExpression { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::StructArray; use crate::assert_arrays_eq; @@ -155,6 +157,8 @@ mod tests { use crate::scalar::Scalar; use crate::scalar_fn::fns::literal::Literal; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn optimize_or_chain_correctness() -> VortexResult<()> { let expr = or( @@ -176,7 +180,7 @@ mod tests { assert_arrays_eq!( actual, BoolArray::from_iter([false, true, true, false]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } diff --git a/vortex-array/src/expr/proto.rs b/vortex-array/src/expr/proto.rs index fae410aaaa7..273bb0d1166 100644 --- a/vortex-array/src/expr/proto.rs +++ b/vortex-array/src/expr/proto.rs @@ -101,11 +101,12 @@ pub fn deserialize_expr_proto( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use prost::Message; use vortex_session::VortexSession; use super::ExprSerializeProtoExt; - use crate::array_session; use crate::expr::Expression; use crate::expr::and; use crate::expr::between; @@ -119,6 +120,12 @@ mod tests { use crate::scalar_fn::fns::between::StrictComparison; use crate::scalar_fn::session::ScalarFnSession; + static SESSION: LazyLock = LazyLock::new(|| { + let session = VortexSession::empty().with::(); + session.allow_unknown(); + session + }); + #[test] fn expression_serde() { let expr: Expression = or( @@ -140,23 +147,20 @@ mod tests { let s_expr = expr.serialize_proto().unwrap(); let buf = s_expr.encode_to_vec(); let s_expr = pb::Expr::decode(buf.as_slice()).unwrap(); - let deser_expr = Expression::from_proto(&s_expr, &array_session()).unwrap(); + let deser_expr = Expression::from_proto(&s_expr, &VortexSession::empty()).unwrap(); assert_eq!(&deser_expr, &expr); } #[test] fn unknown_expression_id_allow_unknown() { - let session = VortexSession::empty().with::(); - session.allow_unknown(); - let expr_proto = pb::Expr { id: "vortex.test.foreign_scalar_fn".to_string(), metadata: Some(vec![1, 2, 3, 4]), children: vec![root().serialize_proto().unwrap()], }; - let expr = Expression::from_proto(&expr_proto, &session).unwrap(); + let expr = Expression::from_proto(&expr_proto, &SESSION).unwrap(); assert_eq!( expr.as_scalar().map(|f| f.id().as_ref().to_string()), Some("vortex.test.foreign_scalar_fn".to_string()) diff --git a/vortex-array/src/expr/stats/mod.rs b/vortex-array/src/expr/stats/mod.rs index 6ab4930064f..b4535de2654 100644 --- a/vortex-array/src/expr/stats/mod.rs +++ b/vortex-array/src/expr/stats/mod.rs @@ -270,18 +270,22 @@ impl Display for Stat { #[cfg(test)] mod test { + use std::sync::LazyLock; + use enum_iterator::all; + use vortex_session::VortexSession; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::expr::stats::Stat; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn min_of_nulls_is_not_panic() { let min = PrimitiveArray::from_option_iter::([None, None, None, None]) .statistics() - .compute_as::(Stat::Min, &mut array_session().create_execution_ctx()); + .compute_as::(Stat::Min, &mut SESSION.create_execution_ctx()); assert_eq!(min, None); } diff --git a/vortex-array/src/expr/transform/match_between.rs b/vortex-array/src/expr/transform/match_between.rs index 4d5a576cc6e..cd506807e46 100644 --- a/vortex-array/src/expr/transform/match_between.rs +++ b/vortex-array/src/expr/transform/match_between.rs @@ -216,14 +216,16 @@ impl<'a> RangeComparison<'a> { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::find_between; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::StructArray; use crate::dtype::DType; @@ -244,6 +246,8 @@ mod tests { use crate::scalar_fn::fns::between::BetweenOptions; use crate::scalar_fn::fns::between::StrictComparison; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn scope() -> DType { let i32_dtype = DType::Primitive(PType::I32, Nullability::NonNullable); DType::Struct( @@ -376,8 +380,7 @@ mod tests { /// keeps a row false when the surviving comparison is false, so the rewrite cannot null it. #[test] fn null_literal_bound_is_value_preserving() -> VortexResult<()> { - let session = array_session(); - let ctx = &mut session.create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); let data = StructArray::from_fields(&[("x", buffer![10, 1].into_array())])?.into_array(); let null_lit = lit(Scalar::null(DType::Primitive( diff --git a/vortex-array/src/lib.rs b/vortex-array/src/lib.rs index 4eb2620fe82..53ccf53bb52 100644 --- a/vortex-array/src/lib.rs +++ b/vortex-array/src/lib.rs @@ -92,13 +92,7 @@ use vortex_session::SessionExt; use vortex_session::VortexSession; use vortex_session::registry::Interner; -use crate::aggregate_fn::session::AggregateFnSession; -use crate::dtype::session::DTypeSession; -use crate::memory::MemorySession; use crate::optimizer::kernels::KernelSession; -use crate::scalar_fn::session::ScalarFnSession; -use crate::session::ArraySession; -use crate::stats::session::StatsSession; pub mod aggregate_fn; #[doc(hidden)] @@ -155,24 +149,4 @@ pub fn initialize(session: &VortexSession) { } } -/// Builds a fresh [`VortexSession`] registered with all of vortex-array's built-in session -/// variables: arrays, dtypes, scalar functions, stats, optimizer kernels, aggregate functions, -/// and memory. -/// -/// Each call returns an independent session (with its own registries), so callers may register -/// additional encodings or kernels into it without affecting any other session. This does not -/// register file, layout, or runtime state — those live in higher-level crates. Arrow -/// interoperability lives in the `vortex-arrow` crate, whose session variables are registered -/// lazily on first use (or eagerly by consumers). -pub fn array_session() -> VortexSession { - VortexSession::empty() - .with::() - .with::() - .with::() - .with::() - .with::() - .with::() - .with::() -} - pub type ArrayContext = Interner; diff --git a/vortex-array/src/mask.rs b/vortex-array/src/mask.rs index f7cee617ccb..561bb3ecdc1 100644 --- a/vortex-array/src/mask.rs +++ b/vortex-array/src/mask.rs @@ -61,13 +61,15 @@ impl NullAsFalse { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::ExecutionCtx; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::builtins::ArrayBuiltins; @@ -75,8 +77,10 @@ mod tests { use crate::dtype::Nullability; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn ctx() -> ExecutionCtx { - array_session().create_execution_ctx() + SESSION.create_execution_ctx() } #[test] diff --git a/vortex-array/src/normalize.rs b/vortex-array/src/normalize.rs index 33f4de740ad..302ae3d1f47 100644 --- a/vortex-array/src/normalize.rs +++ b/vortex-array/src/normalize.rs @@ -99,7 +99,10 @@ impl ArrayRef { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use vortex_utils::aliases::hash_set::HashSet; use super::NormalizeOptions; @@ -119,6 +122,8 @@ mod tests { use crate::assert_arrays_eq; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn normalize_with_execution_keeps_parent_when_children_are_unchanged() -> VortexResult<()> { let field = PrimitiveArray::from_iter(0i32..4).into_array(); @@ -130,7 +135,7 @@ mod tests { )? .into_array(); let allowed = HashSet::from_iter([array.encoding_id(), field.encoding_id()]); - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let normalized = array.clone().normalize(&mut NormalizeOptions { allowed: &allowed, @@ -175,7 +180,7 @@ mod tests { )? .into_array(); let allowed = HashSet::from_iter([array.encoding_id(), unchanged.encoding_id()]); - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let normalized = array.clone().normalize(&mut NormalizeOptions { allowed: &allowed, @@ -218,7 +223,7 @@ mod tests { assert_eq!(sliced.encoding_id(), Slice.id()); let allowed = HashSet::from_iter([Dict.id(), Primitive.id()]); - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let normalized = sliced.normalize(&mut NormalizeOptions { allowed: &allowed, diff --git a/vortex-array/src/optimizer/kernels.rs b/vortex-array/src/optimizer/kernels.rs index 4df7ef99480..6a7eca5d6d6 100644 --- a/vortex-array/src/optimizer/kernels.rs +++ b/vortex-array/src/optimizer/kernels.rs @@ -377,6 +377,8 @@ impl ArrayKernelsExt for S {} #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_session::VortexSession; use super::ArrayKernelsExt; @@ -386,11 +388,12 @@ mod tests { use crate::scalar_fn::ScalarFnVTable; use crate::scalar_fn::fns::binary::Binary; + static SESSION: LazyLock = + LazyLock::new(|| VortexSession::empty().with::()); + #[test] fn kernel_session_default_registers_builtin_kernels() { - let session = VortexSession::empty().with::(); - - assert!(session.kernels().has_execute_parent(Binary.id(), Bool.id())); + assert!(SESSION.kernels().has_execute_parent(Binary.id(), Bool.id())); } #[test] diff --git a/vortex-array/src/patches.rs b/vortex-array/src/patches.rs index b46c9ba90d2..3dab7b37c3d 100644 --- a/vortex-array/src/patches.rs +++ b/vortex-array/src/patches.rs @@ -1354,6 +1354,8 @@ fn take_indices_with_search_fn< #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::BitBuffer; use vortex_buffer::Buffer; @@ -1362,19 +1364,21 @@ mod test { use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::assert_arrays_eq; use crate::patches::Patches; use crate::patches::PrimitiveArray; use crate::search_sorted::SearchResult; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_filter() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 100, 0, @@ -1404,7 +1408,7 @@ mod test { #[test] fn take_with_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 20, 0, @@ -1448,7 +1452,7 @@ mod test { #[test] fn take_search_with_nulls_chunked() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 20, 0, @@ -1493,7 +1497,7 @@ mod test { #[test] fn take_search_chunked_multiple_chunks() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 2048, 0, @@ -1528,7 +1532,7 @@ mod test { #[test] fn take_search_chunked_indices_with_no_patches() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 20, 0, @@ -1552,7 +1556,7 @@ mod test { #[test] fn take_search_chunked_interleaved() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 30, 0, @@ -1587,7 +1591,7 @@ mod test { #[test] fn test_take_search_multiple_chunk_offsets() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 1500, 0, @@ -1622,7 +1626,7 @@ mod test { #[test] fn doubly_sliced() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = buffer![15_u32, 135, 13531, 42].into_array(); let indices = buffer![10_u64, 11, 50, 100].into_array(); @@ -1658,7 +1662,7 @@ mod test { #[test] fn test_mask_all_true() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -1676,7 +1680,7 @@ mod test { #[test] fn test_mask_all_false() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -1711,7 +1715,7 @@ mod test { #[test] fn test_mask_partial() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -1746,7 +1750,7 @@ mod test { #[test] fn test_mask_with_offset() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 5, // offset @@ -1779,7 +1783,7 @@ mod test { #[test] fn test_mask_nullable_values() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -1834,7 +1838,7 @@ mod test { #[values(true, false)] cache_mask_indices: bool, ) -> VortexResult<()> { const LEN: usize = 1000; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( LEN, @@ -1901,7 +1905,7 @@ mod test { /// Mask indices past the maximum of the patch index type cannot match a patch. #[test] fn test_filter_sparse_mask_past_index_type_max() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 1000, 0, @@ -1932,7 +1936,7 @@ mod test { #[test] fn test_filter_keep_all() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -1961,7 +1965,7 @@ mod test { #[test] fn test_filter_none() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -1980,7 +1984,7 @@ mod test { #[test] fn test_filter_with_indices() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -2009,7 +2013,7 @@ mod test { #[test] fn test_slice_full_range() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -2036,7 +2040,7 @@ mod test { #[test] fn test_slice_partial() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -2066,7 +2070,7 @@ mod test { #[test] fn test_slice_no_patches() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -2084,7 +2088,7 @@ mod test { #[test] fn test_slice_with_offset() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 5, // offset @@ -2113,7 +2117,7 @@ mod test { #[test] fn test_indices_range() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -2130,7 +2134,7 @@ mod test { #[test] fn test_search_index() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -2176,7 +2180,7 @@ mod test { #[test] fn test_mask_boundary_patches() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test masking patches at array boundaries let patches = Patches::new( 10, @@ -2208,7 +2212,7 @@ mod test { #[test] fn test_mask_all_patches_removed() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test when all patches are masked out let patches = Patches::new( 10, @@ -2230,7 +2234,7 @@ mod test { #[test] fn test_mask_no_patches_removed() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test when no patches are masked let patches = Patches::new( 10, @@ -2262,7 +2266,7 @@ mod test { #[test] fn test_mask_single_patch() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test with a single patch let patches = Patches::new( 5, @@ -2296,7 +2300,7 @@ mod test { #[test] fn test_mask_contiguous_patches() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test with contiguous patches let patches = Patches::new( 10, @@ -2328,7 +2332,7 @@ mod test { #[test] fn test_mask_with_large_offset() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test with a large offset that shifts all indices let patches = Patches::new( 20, @@ -2362,7 +2366,7 @@ mod test { #[test] #[should_panic(expected = "Filter mask length 5 does not match array length 10")] fn test_mask_wrong_length() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let patches = Patches::new( 10, 0, @@ -2380,7 +2384,7 @@ mod test { #[test] fn test_chunk_offsets_search() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = buffer![100u64, 200, 3000, 3100].into_array(); let values = buffer![10i32, 20, 30, 40].into_array(); let chunk_offsets = buffer![0u64, 2, 2, 3].into_array(); @@ -2427,7 +2431,7 @@ mod test { #[test] fn test_chunk_offsets_with_slice() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = buffer![100u64, 500, 1200, 1300, 1500, 1800, 2100, 2500].into_array(); let values = buffer![10i32, 20, 30, 35, 40, 45, 50, 60].into_array(); let chunk_offsets = buffer![0u64, 2, 6].into_array(); @@ -2465,7 +2469,7 @@ mod test { #[test] fn test_chunk_offsets_with_slice_after_first_chunk() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = buffer![100u64, 500, 1200, 1300, 1500, 1800, 2100, 2500].into_array(); let values = buffer![10i32, 20, 30, 35, 40, 45, 50, 60].into_array(); let chunk_offsets = buffer![0u64, 2, 6].into_array(); @@ -2506,7 +2510,7 @@ mod test { #[test] fn test_chunk_offsets_slice_empty_result() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = buffer![100u64, 200, 3000, 3100].into_array(); let values = buffer![10i32, 20, 30, 40].into_array(); let chunk_offsets = buffer![0u64, 2, 2, 3].into_array(); @@ -2519,7 +2523,7 @@ mod test { #[test] fn test_chunk_offsets_slice_single_patch() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = buffer![100u64, 1200, 1300, 2500].into_array(); let values = buffer![10i32, 20, 30, 40].into_array(); let chunk_offsets = buffer![0u64, 1, 3].into_array(); @@ -2551,7 +2555,7 @@ mod test { #[test] fn test_chunk_offsets_slice_across_chunks() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = buffer![100u64, 200, 1100, 1200, 2100, 2200].into_array(); let values = buffer![10i32, 20, 30, 40, 50, 60].into_array(); let chunk_offsets = buffer![0u64, 2, 4].into_array(); @@ -2588,7 +2592,7 @@ mod test { #[test] fn test_chunk_offsets_boundary_searches() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = buffer![1023u64, 1024, 1025, 2047, 2048].into_array(); let values = buffer![10i32, 20, 30, 40, 50].into_array(); let chunk_offsets = buffer![0u64, 1, 4].into_array(); @@ -2628,7 +2632,7 @@ mod test { #[test] fn test_chunk_offsets_slice_edge_cases() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = buffer![0u64, 1, 1023, 1024, 2047, 2048].into_array(); let values = buffer![10i32, 20, 30, 40, 50, 60].into_array(); let chunk_offsets = buffer![0u64, 3, 5].into_array(); @@ -2673,7 +2677,7 @@ mod test { #[test] fn test_chunk_offsets_slice_nested() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let indices = buffer![100u64, 200, 300, 400, 500, 600].into_array(); let values = buffer![10i32, 20, 30, 40, 50, 60].into_array(); let chunk_offsets = buffer![0u64].into_array(); @@ -2709,7 +2713,7 @@ mod test { #[test] fn test_nested_slice_with_dropped_first_chunk() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // PATCH_CHUNK_SIZE = 1024, so the two patches land in different chunks. let indices = buffer![0u64, 1024].into_array(); let values = buffer![1i32, 2].into_array(); @@ -2736,7 +2740,7 @@ mod test { #[test] fn test_index_larger_than_length() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let chunk_offsets = buffer![0u64].into_array(); let indices = buffer![1023u64].into_array(); let values = buffer![42i32].into_array(); diff --git a/vortex-array/src/scalar/tests/mod.rs b/vortex-array/src/scalar/tests/mod.rs index 676363c853c..c208e7870ed 100644 --- a/vortex-array/src/scalar/tests/mod.rs +++ b/vortex-array/src/scalar/tests/mod.rs @@ -14,4 +14,4 @@ use std::sync::LazyLock; use vortex_session::VortexSession; -pub(crate) static SESSION: LazyLock = LazyLock::new(crate::array_session); +pub(crate) static SESSION: LazyLock = LazyLock::new(VortexSession::empty); diff --git a/vortex-array/src/scalar_fn/fns/between/mod.rs b/vortex-array/src/scalar_fn/fns/between/mod.rs index adc269b40fc..9ba0173975d 100644 --- a/vortex-array/src/scalar_fn/fns/between/mod.rs +++ b/vortex-array/src/scalar_fn/fns/between/mod.rs @@ -364,7 +364,7 @@ mod tests { use crate::test_harness::to_int_indices; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); const NON_STRICT: BetweenOptions = BetweenOptions { lower_strict: StrictComparison::NonStrict, diff --git a/vortex-array/src/scalar_fn/fns/binary/boolean.rs b/vortex-array/src/scalar_fn/fns/binary/boolean.rs index 82fe334a2d2..df23e5a87cb 100644 --- a/vortex-array/src/scalar_fn/fns/binary/boolean.rs +++ b/vortex-array/src/scalar_fn/fns/binary/boolean.rs @@ -748,13 +748,15 @@ fn is_boolean_operator(operator: Operator) -> bool { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::assert_arrays_eq; @@ -764,9 +766,11 @@ mod tests { use crate::scalar::Scalar; use crate::scalar_fn::fns::operators::Operator; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_kleene_truth_table() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = BoolArray::from_iter([ Some(true), Some(true), @@ -829,7 +833,7 @@ mod tests { #[test] fn test_null_constant_kleene() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = BoolArray::from_iter([Some(false), Some(true), None]).into_array(); let null = ConstantArray::new(Scalar::null(DType::Bool(Nullability::Nullable)), lhs.len()) .into_array(); @@ -858,27 +862,27 @@ mod tests { BoolArray::from_iter([Some(true), Some(true), Some(false), Some(false)]).into_array(), )] fn test_or(#[case] lhs: ArrayRef, #[case] rhs: ArrayRef) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let r = lhs.binary(rhs, Operator::Or).unwrap(); let r = r.execute::(&mut ctx).unwrap().into_array(); let v0 = r - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .as_bool() .value(); let v1 = r - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .as_bool() .value(); let v2 = r - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() .as_bool() .value(); let v3 = r - .execute_scalar(3, &mut array_session().create_execution_ctx()) + .execute_scalar(3, &mut SESSION.create_execution_ctx()) .unwrap() .as_bool() .value(); @@ -899,7 +903,7 @@ mod tests { BoolArray::from_iter([Some(true), Some(true), Some(false), Some(false)]).into_array(), )] fn test_and(#[case] lhs: ArrayRef, #[case] rhs: ArrayRef) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let r = lhs .binary(rhs, Operator::And) .unwrap() @@ -908,22 +912,22 @@ mod tests { .into_array(); let v0 = r - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .as_bool() .value(); let v1 = r - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .as_bool() .value(); let v2 = r - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() .as_bool() .value(); let v3 = r - .execute_scalar(3, &mut array_session().create_execution_ctx()) + .execute_scalar(3, &mut SESSION.create_execution_ctx()) .unwrap() .as_bool() .value(); diff --git a/vortex-array/src/scalar_fn/fns/binary/compare/tests.rs b/vortex-array/src/scalar_fn/fns/binary/compare/tests.rs index 0b6e3be6426..83d01e2d831 100644 --- a/vortex-array/src/scalar_fn/fns/binary/compare/tests.rs +++ b/vortex-array/src/scalar_fn/fns/binary/compare/tests.rs @@ -2,6 +2,7 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::Ordering; use rstest::rstest; @@ -9,11 +10,11 @@ use vortex_buffer::BitBuffer; use vortex_buffer::buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::DecimalArray; @@ -47,9 +48,11 @@ use crate::scalar_fn::fns::operators::CompareOperator; use crate::scalar_fn::fns::operators::Operator; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_bool_basic_comparisons() { - let ctx = &mut array_session().create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); let arr = BoolArray::new( BitBuffer::from_iter([true, true, false, true, false]), Validity::from_iter([false, true, true, true, true]), @@ -137,13 +140,13 @@ fn constant_compare() { .unwrap(); assert_eq!(result.len(), 10); let scalar = result - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(); assert_eq!(scalar.as_bool().value(), Some(false)); assert_arrays_eq!( result, BoolArray::from_iter([false; 10]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -153,7 +156,7 @@ fn constant_compare() { #[case(VarBinArray::from(vec!["a".as_bytes(), "b".as_bytes()]).into_array(), VarBinViewArray::from_iter_bin(["a".as_bytes(), "b".as_bytes()]).into_array())] #[case(VarBinViewArray::from_iter_bin(["a".as_bytes(), "b".as_bytes()]).into_array(), VarBinArray::from(vec!["a".as_bytes(), "b".as_bytes()]).into_array())] fn compare_different_encodings(#[case] left: ArrayRef, #[case] right: ArrayRef) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let res = left.binary(right, Operator::Eq).unwrap(); let expected = BoolArray::from_iter([true, true]); assert_arrays_eq!(res, expected, &mut ctx); @@ -161,7 +164,7 @@ fn compare_different_encodings(#[case] left: ArrayRef, #[case] right: ArrayRef) #[test] fn test_list_array_comparison() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values1 = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6]); let offsets1 = PrimitiveArray::from_iter([0i32, 2, 4, 6]); let list1 = ListArray::try_new( @@ -208,7 +211,7 @@ fn test_list_array_comparison() { #[test] fn test_list_array_constant_comparison() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6]); let offsets = PrimitiveArray::from_iter([0i32, 2, 4, 6]); let list = ListArray::try_new( @@ -236,7 +239,7 @@ fn test_list_array_constant_comparison() { #[test] fn test_struct_array_comparison() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bool_field1 = BoolArray::from_iter([Some(true), Some(false), Some(true)]); let int_field1 = PrimitiveArray::from_iter([1i32, 2, 3]); @@ -273,7 +276,7 @@ fn test_struct_array_comparison() { #[test] fn test_empty_struct_compare() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let empty1 = StructArray::try_new( FieldNames::from(Vec::::new()), Vec::new(), @@ -302,7 +305,7 @@ fn test_empty_struct_compare() { /// different Vortex encodings (VarBinArray vs VarBinViewArray) must not panic. #[test] fn struct_compare_mixed_binary_encodings() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // LHS: struct with a VarBinArray (offset-based) binary field let bin_field1 = VarBinArray::from(vec![ "apple".as_bytes(), @@ -358,7 +361,7 @@ fn scalar_cmp_incompatible_extension_types_errors() { #[test] fn test_empty_list() { - let ctx = &mut array_session().create_execution_ctx(); + let ctx = &mut SESSION.create_execution_ctx(); let list = ListViewArray::new( BoolArray::from_iter(Vec::::new()).into_array(), buffer![0i32, 0i32, 0i32].into_array(), @@ -385,7 +388,7 @@ fn execute_compare_test(lhs: ArrayRef, rhs: ArrayRef, op: Operator) -> ArrayRef #[test] fn comparison_uses_execution_allocator() -> VortexResult<()> { let (allocator, allocations) = counting_allocator(); - let mut ctx = array_session() + let mut ctx = VortexSession::empty() .with_allocator(allocator) .create_execution_ctx(); let result = buffer![1i32, 2, 3] @@ -405,7 +408,7 @@ fn comparison_uses_execution_allocator() -> VortexResult<()> { #[case(Operator::Gt, [false, false, true, false])] #[case(Operator::Gte, [false, true, true, false])] fn int_all_operators(#[case] op: Operator, #[case] expected: [bool; 4]) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = buffer![1i32, 5, 9, 2].into_array(); let rhs = buffer![3i32, 5, 7, 4].into_array(); let result = execute_compare_test(lhs, rhs, op); @@ -416,7 +419,7 @@ fn int_all_operators(#[case] op: Operator, #[case] expected: [bool; 4]) { #[case(Operator::Lt, [Some(true), None, Some(false), None])] #[case(Operator::Eq, [Some(false), None, Some(false), None])] fn int_nullable(#[case] op: Operator, #[case] expected: [Option; 4]) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = PrimitiveArray::from_option_iter([Some(1i64), None, Some(9), Some(2)]).into_array(); let rhs = PrimitiveArray::from_option_iter([Some(3i64), Some(5), Some(7), None]).into_array(); let result = execute_compare_test(lhs, rhs, op); @@ -427,7 +430,7 @@ fn int_nullable(#[case] op: Operator, #[case] expected: [Option; 4]) { #[case(Operator::Gt, [false, false, true, false])] #[case(Operator::Lte, [true, true, false, true])] fn int_constant_lhs_and_rhs(#[case] op: Operator, #[case] expected: [bool; 4]) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = buffer![1i32, 5, 9, 2].into_array(); let constant = ConstantArray::new(5i32, 4).into_array(); @@ -448,7 +451,7 @@ fn int_constant_lhs_and_rhs(#[case] op: Operator, #[case] expected: [bool; 4]) { /// and -0.0 < +0.0. This matches `Scalar` comparison semantics. #[test] fn float_total_order() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = buffer![f64::NAN, f64::NAN, -0.0f64, 1.0].into_array(); let rhs = buffer![f64::NAN, f64::INFINITY, 0.0f64, f64::NAN].into_array(); @@ -472,7 +475,7 @@ fn float_total_order() { #[case(Operator::Lt, [false, true, false, false])] #[case(Operator::Gte, [true, false, true, true])] fn bool_constant(#[case] op: Operator, #[case] expected: [bool; 4]) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = BoolArray::from_iter([true, false, true, true]).into_array(); let constant = ConstantArray::new(true, 4).into_array(); let result = execute_compare_test(array, constant, op); @@ -501,7 +504,7 @@ fn string_compare_cases( #[case] op: Operator, #[case] expected: bool, ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = VarBinViewArray::from_iter_str([lhs]).into_array(); let rhs = VarBinViewArray::from_iter_str([rhs]).into_array(); let result = execute_compare_test(lhs, rhs, op); @@ -510,7 +513,7 @@ fn string_compare_cases( #[test] fn string_constant_compare() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str([ "apple", "banana", @@ -545,7 +548,7 @@ fn string_constant_compare() { #[test] fn string_constant_longer_than_inline() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["short", "averyveryverylongstring", "averyvery"]) .into_array(); let constant = ConstantArray::new(Scalar::from("averyveryverylongstring"), 3).into_array(); @@ -559,7 +562,7 @@ fn string_constant_longer_than_inline() { #[test] fn decimal_compare() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let lhs = DecimalArray::from_iter::([100, 250, 300], dtype).into_array(); let rhs = DecimalArray::from_iter::([200, 250, 100], dtype).into_array(); @@ -572,7 +575,7 @@ fn decimal_compare() { /// the widened common storage type. #[test] fn decimal_compare_mixed_storage_widths() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let lhs = DecimalArray::from_iter::([100, 250, 300], dtype).into_array(); let rhs = DecimalArray::from_iter::([200, 250, 100], dtype).into_array(); @@ -585,7 +588,7 @@ fn decimal_compare_mixed_storage_widths() { /// correctly: it is greater than every representable array value. #[test] fn decimal_constant_out_of_storage_range() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(20, 2); let array = DecimalArray::from_iter::([1, 50, 100], dtype).into_array(); let constant = ConstantArray::new( @@ -612,7 +615,7 @@ fn decimal_constant_out_of_storage_range() { /// Extension arrays compare through their storage values. #[test] fn extension_timestamp_compare() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ext_dtype = Timestamp::new(TimeUnit::Milliseconds, Nullability::NonNullable).erased(); let lhs = ExtensionArray::new(ext_dtype.clone(), buffer![1000i64, 2000, 3000].into_array()) .into_array(); @@ -630,7 +633,7 @@ fn extension_timestamp_compare() { /// units) must error rather than silently comparing raw storage values. #[test] fn extension_mismatched_units_errors() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ms = ExtensionArray::new( Timestamp::new(TimeUnit::Milliseconds, Nullability::NonNullable).erased(), buffer![1000i64, 2000].into_array(), @@ -652,7 +655,7 @@ fn extension_mismatched_units_errors() { /// only top-level nulls make the result null. #[test] fn struct_compare_null_fields_order_first() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = StructArray::from_fields(&[( "a", PrimitiveArray::from_option_iter([None, Some(5i32), None]).into_array(), @@ -676,7 +679,7 @@ fn struct_compare_null_fields_order_first() { #[test] fn fixed_size_list_compare() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = FixedSizeListArray::new( buffer![1i32, 2, 3, 4, 5, 6].into_array(), 2, @@ -702,7 +705,7 @@ fn fixed_size_list_compare() { /// Binary (non-utf8) comparison over VarBinView arrays. #[test] fn binary_compare() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = VarBinViewArray::from_iter_bin([b"bad".as_slice(), b"\xff\x00", b""]).into_array(); let rhs = VarBinViewArray::from_iter_bin([b"bat".as_slice(), b"\xff", b""]).into_array(); @@ -776,7 +779,7 @@ fn map_compare_all_operators( #[case] op: Operator, #[case] expected: [bool; 5], ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = map_array( Nullability::NonNullable, [ @@ -812,7 +815,7 @@ fn map_compare_all_operators( /// Only top-level nulls make a map comparison null; an empty map is not a null map. #[test] fn map_compare_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = map_array( Nullability::Nullable, [None, None, Some(vec![]), Some(vec![(1, Some("a"))])], @@ -833,7 +836,7 @@ fn map_compare_nulls() -> VortexResult<()> { /// [`scalar_cmp`], agree with the row-wise kernel. #[test] fn map_constant_compare() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = map_array( Nullability::NonNullable, [ @@ -875,7 +878,7 @@ fn map_constant_compare() -> VortexResult<()> { /// Maps nested inside another nested type compare through the same row comparator tree. #[test] fn struct_of_map_compare() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = StructArray::from_fields(&[( "m", map_array( @@ -916,7 +919,7 @@ fn byte_comparisons_across_bitmap_words( )] op: CompareOperator, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let value_for_type = |value: Option| { value.map(|value| { if ptype.is_unsigned_int() { diff --git a/vortex-array/src/scalar_fn/fns/binary/mod.rs b/vortex-array/src/scalar_fn/fns/binary/mod.rs index bbd0ab2a5db..42cebc8401c 100644 --- a/vortex-array/src/scalar_fn/fns/binary/mod.rs +++ b/vortex-array/src/scalar_fn/fns/binary/mod.rs @@ -326,13 +326,15 @@ impl ScalarFnVTable for Binary { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexExpect; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::*; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Bool; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; @@ -362,6 +364,8 @@ mod tests { use crate::optimizer::ArrayOptimizer; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn and_collect_balanced() { let values = vec![lit(1), lit(2), lit(3), lit(4), lit(5)]; @@ -541,7 +545,7 @@ mod tests { let result_equal = lhs_struct.binary(rhs_struct_equal, Operator::Eq).unwrap(); assert_eq!( result_equal - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .vortex_expect("value"), Scalar::bool(true, Nullability::NonNullable), "Equal structs should be equal" @@ -552,7 +556,7 @@ mod tests { .unwrap(); assert_eq!( result_different - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .vortex_expect("value"), Scalar::bool(false, Nullability::NonNullable), "Different structs should not be equal" @@ -561,7 +565,7 @@ mod tests { #[test] fn test_or_kleene_validity() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); use crate::arrays::StructArray; use crate::expr::col; @@ -587,7 +591,7 @@ mod tests { #[test] fn test_and_reduce() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let left = BoolArray::from_iter([true, true, false]).into_array(); let right = ConstantArray::new(true, 3).into_array(); @@ -634,7 +638,7 @@ mod tests { #[test] fn test_and_reduce_nullable() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let nullable_true = ConstantArray::new(Scalar::bool(true, Nullability::Nullable), 3).into_array(); let right = BoolArray::from_iter([true, false, true]).into_array(); @@ -655,7 +659,7 @@ mod tests { #[test] fn test_isnull_and_reduce() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let left = BoolArray::from_iter([Some(true), Some(true), None]).into_array(); let right = BoolArray::from_iter([true, false, true]).into_array(); @@ -680,7 +684,7 @@ mod tests { #[test] fn test_isnotnull_or_reduce() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let left = BoolArray::from_iter([Some(true), Some(true), None]).into_array(); let right = BoolArray::from_iter([true, false, true]).into_array(); diff --git a/vortex-array/src/scalar_fn/fns/binary/numeric/tests.rs b/vortex-array/src/scalar_fn/fns/binary/numeric/tests.rs index 067aaec41d9..325e55665f8 100644 --- a/vortex-array/src/scalar_fn/fns/binary/numeric/tests.rs +++ b/vortex-array/src/scalar_fn/fns/binary/numeric/tests.rs @@ -1,10 +1,13 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use super::numeric_op_result_decimal_dtype as result_decimal_dtype; use crate::ArrayRef; @@ -12,7 +15,6 @@ use crate::Columnar; use crate::IntoArray; use crate::RecursiveCanonical; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::ConstantArray; use crate::arrays::DecimalArray; use crate::arrays::PrimitiveArray; @@ -32,6 +34,8 @@ use crate::scalar::Scalar; use crate::scalar_fn::fns::operators::Operator; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn sub_scalar(array: &ArrayRef, scalar: impl Into) -> VortexResult { array.binary( ConstantArray::new(scalar, array.len()).into_array(), @@ -41,7 +45,7 @@ fn sub_scalar(array: &ArrayRef, scalar: impl Into) -> VortexResult(&mut array_session().create_execution_ctx())); + .and_then(|a| a.execute::(&mut SESSION.create_execution_ctx())); assert!(result.is_err()); } @@ -134,7 +138,7 @@ fn test_integer_divide_by_zero_errors() { ConstantArray::new(0i32, values.len()).into_array(), Operator::Div, ) - .and_then(|a| a.execute::(&mut array_session().create_execution_ctx())); + .and_then(|a| a.execute::(&mut SESSION.create_execution_ctx())); assert!(result.is_err()); } @@ -147,14 +151,14 @@ fn test_integer_divide_overflow_errors() { ConstantArray::new(-1i64, values.len()).into_array(), Operator::Div, ) - .and_then(|a| a.execute::(&mut array_session().create_execution_ctx())); + .and_then(|a| a.execute::(&mut SESSION.create_execution_ctx())); assert!(result.is_err()); } #[test] fn test_integer_divide_errors_ignore_null_lanes() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = PrimitiveArray::new(buffer![10i32, 10], Validity::from_iter([false, true])).into_array(); let rhs = buffer![0i32, 2].into_array(); @@ -169,7 +173,7 @@ fn test_integer_divide_errors_ignore_null_lanes() { #[test] fn test_integer_errors_ignore_null_lanes() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::new(buffer![u8::MAX, 1], Validity::from_iter([false, true])).into_array(); let result = values @@ -196,7 +200,7 @@ fn test_integer_array_array_errors_on_valid_lanes() { let rhs = buffer![1u8, 1, 1].into_array(); let result = lhs .binary(rhs, Operator::Add) - .and_then(|a| a.execute::(&mut array_session().create_execution_ctx())); + .and_then(|a| a.execute::(&mut SESSION.create_execution_ctx())); assert!(result.is_err()); } @@ -204,7 +208,7 @@ fn test_integer_array_array_errors_on_valid_lanes() { /// Assert one checked multiplication through the complete array execution path. #[track_caller] fn assert_multiply(lhs: T, rhs: T, expected: Option) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = PrimitiveArray::from_iter([lhs, lhs]) .into_array() .binary( @@ -271,7 +275,7 @@ fn test_multiply_overflow_on_null_lane_ignored( #[case] rhs: T, #[case] expected: T, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lhs = PrimitiveArray::new( Buffer::copy_from([overflowing, rhs]), Validity::from_iter([false, true]), @@ -302,7 +306,7 @@ fn test_multiply_overflow_survives_batch_reduction( const LEN: u32 = 1000; const OVERFLOW_AT: u32 = 700; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut lhs: Vec = (0..LEN).map(|i| i % 100 + 1).collect(); lhs[OVERFLOW_AT as usize] = u32::MAX; @@ -335,7 +339,7 @@ fn test_multiply_overflow_survives_batch_reduction( #[test] fn test_present_nullable_constant_preserves_nullable_output() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = buffer![1u8, 2].into_array(); let result = values .binary( @@ -358,7 +362,7 @@ fn test_empty_primitive_constants_do_not_evaluate() -> VortexResult<()> { let result = lhs .binary(rhs, Operator::Add)? - .execute::(&mut array_session().create_execution_ctx())?; + .execute::(&mut SESSION.create_execution_ctx())?; assert!(result.0.is_empty()); assert_eq!( @@ -372,7 +376,7 @@ fn test_empty_primitive_constants_do_not_evaluate() -> VortexResult<()> { fn decimal_binary(lhs: ArrayRef, rhs: ArrayRef, op: Operator) -> VortexResult { lhs.binary(rhs, op) - .and_then(|a| a.execute::(&mut array_session().create_execution_ctx())) + .and_then(|a| a.execute::(&mut SESSION.create_execution_ctx())) .map(|a| a.0.into_array()) } @@ -398,7 +402,7 @@ fn test_decimal_array_array( #[case] rhs: [i64; 2], #[case] expected: [i64; 2], ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let result_dtype = result_decimal_dtype(dtype, op)?; let lhs = DecimalArray::from_iter::([900, 1000], dtype).into_array(); @@ -415,7 +419,7 @@ fn test_decimal_array_array( #[test] fn test_decimal_mixed_storage_widths() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let lhs = DecimalArray::from_iter::([100, 250], dtype).into_array(); let rhs = DecimalArray::from_iter::([200, 250], dtype).into_array(); @@ -434,7 +438,7 @@ fn test_decimal_mixed_storage_widths() -> VortexResult<()> { #[test] fn test_decimal_nullable_lanes() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let lhs = DecimalArray::from_option_iter::([Some(100), None, Some(300)], dtype).into_array(); @@ -464,7 +468,7 @@ fn test_decimal_value_outside_working_width_errors() { #[test] fn test_decimal_div_negative_result_scale() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // A negative result scale scales the divisor rather than the dividend: 5e12 / 2e8 is 25_000, // truncated to 2 at the decimal(6, -4) result scale. The i64 working width is also wider than // the i32 result storage, so this narrows on the way out. @@ -508,7 +512,7 @@ fn test_decimal_mul_value_outside_working_width_errors() { #[test] fn test_decimal_value_outside_working_width_on_null_lane_ignored() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(2, 0); let result_dtype = result_decimal_dtype(dtype, NumericOperator::Add)?; let lhs = DecimalArray::new( @@ -530,7 +534,7 @@ fn test_decimal_value_outside_working_width_on_null_lane_ignored() -> VortexResu #[test] fn test_decimal_overflow_on_null_lane_ignored() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(76, 0); let max = ::MAX_BY_PRECISION[76]; let one = i256::from_i128(1); @@ -549,7 +553,7 @@ fn test_decimal_overflow_on_null_lane_ignored() { #[test] fn test_decimal_divide_by_zero_on_null_lane_ignored() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let lhs = DecimalArray::new( buffer![100i64, 1_000], @@ -582,7 +586,7 @@ fn test_decimal_divide_by_zero_on_valid_lane_errors() { #[test] fn test_decimal_add_reserves_carry_digit() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(2, 0); let lhs = DecimalArray::from_iter::([99], dtype).into_array(); let rhs = DecimalArray::from_iter::([99], dtype).into_array(); @@ -597,7 +601,7 @@ fn test_decimal_add_reserves_carry_digit() { #[test] fn test_decimal_mul_widens_before_multiplying() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(38, 0); let max = ::MAX_BY_PRECISION[38]; let widened_max = i256::from_i128(max); @@ -671,7 +675,7 @@ fn test_decimal_result_uses_widened_logical_storage_width( values.into_array(), Operator::Add, )? - .execute::(&mut array_session().create_execution_ctx())?; + .execute::(&mut SESSION.create_execution_ctx())?; assert_eq!(result.values_type(), expected_type); assert_eq!(result.decimal_dtype(), expected_dtype); @@ -681,14 +685,14 @@ fn test_decimal_result_uses_widened_logical_storage_width( [i256::from_i128(20), i256::from_i128(40)], expected_dtype ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } #[test] fn test_decimal_precision_76_boundary() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(76, 0); let max = ::MAX_BY_PRECISION[76]; let zero = i256::from_i128(0); @@ -733,7 +737,7 @@ fn test_decimal_empty_constants_do_not_evaluate() -> VortexResult<()> { #[test] fn test_decimal_constant_lhs_non_commutative() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let lhs = decimal_constant(1000i64, dtype, 2); let rhs = DecimalArray::from_iter::([250, 400], dtype).into_array(); @@ -752,7 +756,7 @@ fn test_decimal_constant_lhs_non_commutative() -> VortexResult<()> { #[test] fn test_decimal_nullable_constant_preserves_nullable_output() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let values = DecimalArray::from_iter::([100, 200], dtype).into_array(); let constant = ConstantArray::new( @@ -784,7 +788,7 @@ fn test_decimal_null_constant_yields_all_null( #[case] null_lhs: bool, #[case] op: NumericOperator, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let values = DecimalArray::from_iter::([100, 200], dtype).into_array(); let null_constant = ConstantArray::new( @@ -812,7 +816,7 @@ fn test_decimal_null_constant_yields_all_null( /// working type. #[test] fn test_decimal_constant_wider_than_array_storage() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(20, 0); let values = DecimalArray::from_iter::([1, 2], dtype).into_array(); let constant = decimal_constant(10_000_000_000i64, dtype, 2); @@ -835,7 +839,7 @@ fn test_decimal_constant_wider_than_array_storage() -> VortexResult<()> { #[case::mul(NumericOperator::Mul)] #[case::div(NumericOperator::Div)] fn test_decimal_empty(#[case] op: NumericOperator) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let empty = DecimalArray::from_iter::([], dtype).into_array(); @@ -857,7 +861,7 @@ fn test_decimal_constant_constant_folds( #[case] op: NumericOperator, #[case] expected: i128, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(10, 2); let lhs = decimal_constant(150i64, dtype, 3); let rhs = decimal_constant(50i64, dtype, 3); diff --git a/vortex-array/src/scalar_fn/fns/byte_length.rs b/vortex-array/src/scalar_fn/fns/byte_length.rs index 4a4cd8328b6..afdf77d118d 100644 --- a/vortex-array/src/scalar_fn/fns/byte_length.rs +++ b/vortex-array/src/scalar_fn/fns/byte_length.rs @@ -166,13 +166,15 @@ pub(crate) fn byte_length( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; use crate::arrays::VarBinArray; @@ -184,6 +186,8 @@ mod tests { use crate::expr::root; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(VarBinArray::from_strs(vec!["hello", "world", ""]).into_array(), vec![5u64, 5, 0])] #[case(VarBinArray::from_bytes(vec![b"ab".as_ref(), b"cde"]).into_array(), vec![2u64, 3])] @@ -193,7 +197,7 @@ mod tests { #[case] array: ArrayRef, #[case] expected_lens: Vec, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = array.apply(&byte_length(root()))?; let expected = PrimitiveArray::from_iter(expected_lens); assert_arrays_eq!(result, expected, &mut ctx); @@ -202,7 +206,7 @@ mod tests { #[test] fn test_varbinview_byte_length() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["short", "a longer string here"]).into_array(); let result = array.apply(&byte_length(root()))?; let expected = PrimitiveArray::from_iter(vec![5u64, 20]); @@ -216,16 +220,16 @@ mod tests { .into_array(); let result = array.apply(&byte_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(result.is_valid(0, &mut ctx)?); assert!(!result.is_valid(1, &mut ctx)?); assert!(result.is_valid(2, &mut ctx)?); assert_eq!( - result.execute_scalar(0, &mut array_session().create_execution_ctx())?, + result.execute_scalar(0, &mut SESSION.create_execution_ctx())?, Scalar::primitive(5u64, Nullability::Nullable), ); assert_eq!( - result.execute_scalar(2, &mut array_session().create_execution_ctx())?, + result.execute_scalar(2, &mut SESSION.create_execution_ctx())?, Scalar::primitive(18u64, Nullability::Nullable), ); assert_arrays_eq!( @@ -241,7 +245,7 @@ mod tests { let null_scalar = Scalar::null(DType::Utf8(Nullability::Nullable)); let array = ConstantArray::new(null_scalar, 2).into_array(); let result = array.apply(&byte_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(!result.is_valid(0, &mut ctx)?); assert!(!result.is_valid(1, &mut ctx)?); assert_arrays_eq!( diff --git a/vortex-array/src/scalar_fn/fns/case_when.rs b/vortex-array/src/scalar_fn/fns/case_when.rs index 1d67f9efe0e..1a2e7f6abb5 100644 --- a/vortex-array/src/scalar_fn/fns/case_when.rs +++ b/vortex-array/src/scalar_fn/fns/case_when.rs @@ -518,7 +518,7 @@ mod tests { use crate::scalar_fn::fns::operators::Operator; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(crate::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn compact_and_run_merges_agree_for_nested_and_nullable_values() -> VortexResult<()> { @@ -811,10 +811,7 @@ mod tests { pb::CaseWhenOpts::decode(serialized.as_slice())?.num_children, num_children ); - assert_eq!( - CaseWhen.deserialize(&serialized, &VortexSession::empty())?, - options - ); + assert_eq!(CaseWhen.deserialize(&serialized, &SESSION)?, options); Ok(()) } @@ -840,11 +837,7 @@ mod tests { #[case::one_child(&[0x08, 1])] #[case::truncated(&[0x08, 0x80])] fn test_deserialization_invalid_metadata(#[case] metadata: &[u8]) { - assert!( - CaseWhen - .deserialize(metadata, &VortexSession::empty()) - .is_err() - ); + assert!(CaseWhen.deserialize(metadata, &SESSION).is_err()); } #[rstest] diff --git a/vortex-array/src/scalar_fn/fns/cast/mod.rs b/vortex-array/src/scalar_fn/fns/cast/mod.rs index 01a74031e20..f3d90cf05fc 100644 --- a/vortex-array/src/scalar_fn/fns/cast/mod.rs +++ b/vortex-array/src/scalar_fn/fns/cast/mod.rs @@ -241,14 +241,16 @@ fn cast_constant(array: ArrayView, dtype: &DType) -> VortexResult = LazyLock::new(VortexSession::empty); + #[test] fn dtype() { let dtype = test_harness::struct_dtype(); @@ -307,7 +311,7 @@ mod tests { assert_arrays_eq!( result, buffer![0i64, 1, 2].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } diff --git a/vortex-array/src/scalar_fn/fns/dynamic.rs b/vortex-array/src/scalar_fn/fns/dynamic.rs index bcc2cfe9c94..3570c06180f 100644 --- a/vortex-array/src/scalar_fn/fns/dynamic.rs +++ b/vortex-array/src/scalar_fn/fns/dynamic.rs @@ -279,16 +279,17 @@ impl DynamicExprUpdates { #[cfg(test)] mod tests { + use std::sync::LazyLock; use std::sync::atomic::AtomicI32; use std::sync::atomic::Ordering; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::*; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::assert_arrays_eq; use crate::dtype::DType; @@ -297,6 +298,8 @@ mod tests { use crate::expr::dynamic; use crate::expr::root; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn is_not_strict() { let expr = dynamic( @@ -329,7 +332,7 @@ mod tests { #[test] fn execute_with_value() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = buffer![1i32, 5, 10].into_array(); let expr = dynamic( CompareOperator::Lt, @@ -345,7 +348,7 @@ mod tests { #[test] fn execute_without_value_default_true() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = buffer![1i32, 5, 10].into_array(); let expr = dynamic( CompareOperator::Lt, @@ -361,7 +364,7 @@ mod tests { #[test] fn execute_without_value_default_false() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = buffer![1i32, 5, 10].into_array(); let expr = dynamic( CompareOperator::Lt, @@ -381,7 +384,7 @@ mod tests { #[test] fn execute_value_flips() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let threshold = Arc::new(AtomicI32::new(5)); let threshold_clone = Arc::clone(&threshold); let expr = dynamic( diff --git a/vortex-array/src/scalar_fn/fns/ext_storage.rs b/vortex-array/src/scalar_fn/fns/ext_storage.rs index ad8e77e9fa7..1e708cf2414 100644 --- a/vortex-array/src/scalar_fn/fns/ext_storage.rs +++ b/vortex-array/src/scalar_fn/fns/ext_storage.rs @@ -95,8 +95,11 @@ impl ScalarFnVTable for ExtStorage { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; @@ -114,6 +117,8 @@ mod tests { use crate::extension::datetime::Timestamp; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn ext_dtype(nullability: Nullability) -> ExtDTypeRef { Timestamp::new(TimeUnit::Nanoseconds, nullability).erased() } @@ -130,11 +135,7 @@ mod tests { result.dtype(), &DType::Primitive(PType::I64, Nullability::NonNullable) ); - assert_arrays_eq!( - result, - storage, - &mut crate::array_session().create_execution_ctx() - ); + assert_arrays_eq!(result, storage, &mut SESSION.create_execution_ctx()); Ok(()) } @@ -150,11 +151,7 @@ mod tests { result.dtype(), &DType::Primitive(PType::I64, Nullability::Nullable) ); - assert_arrays_eq!( - result, - storage, - &mut crate::array_session().create_execution_ctx() - ); + assert_arrays_eq!(result, storage, &mut SESSION.create_execution_ctx()); Ok(()) } @@ -174,7 +171,7 @@ mod tests { assert_arrays_eq!( result, ConstantArray::new(storage_scalar, 3), - &mut crate::array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } diff --git a/vortex-array/src/scalar_fn/fns/fill_null/mod.rs b/vortex-array/src/scalar_fn/fns/fill_null/mod.rs index c5a0a80423e..5d17aaa68b8 100644 --- a/vortex-array/src/scalar_fn/fns/fill_null/mod.rs +++ b/vortex-array/src/scalar_fn/fns/fill_null/mod.rs @@ -237,15 +237,16 @@ fn fill_null_canonical( #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use vortex_buffer::buffer; use vortex_error::VortexExpect; + use vortex_session::VortexSession; use super::*; use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Chunked; use crate::arrays::ChunkedArray; use crate::arrays::Constant; @@ -277,6 +278,8 @@ mod tests { use crate::scalar_fn::fns::binary::Binary; use crate::scalar_fn::fns::operators::Operator; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// A fill of `40 + 2` that is not a [`ConstantArray`] until it executes. fn lazy_fill_42(len: usize) -> VortexResult { Ok(ScalarFnArray::try_new( @@ -309,7 +312,7 @@ mod tests { #[test] fn evaluate() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let test_array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, Some(5)]) .into_array(); @@ -330,7 +333,7 @@ mod tests { #[test] fn evaluate_lazy_constant_fill() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]).into_array(); let fill = lazy_fill_42(input.len())?; assert!(fill.as_constant().is_none()); @@ -349,7 +352,7 @@ mod tests { #[test] fn evaluate_lazy_fill_preserves_chunked_input() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = ChunkedArray::try_new( vec![ PrimitiveArray::from_option_iter([Some(1i32), None]).into_array(), @@ -375,7 +378,7 @@ mod tests { #[test] fn non_constant_fill_declines_and_errors() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let varying = PrimitiveArray::from_iter([1i32, 2, 3]).into_array(); let constant_input = ConstantArray::new(Scalar::null_native::(), 3).into_array(); @@ -417,7 +420,7 @@ mod tests { /// canonical array rather than a constant. Stacked fills over an empty chunk must still run. #[test] fn repeated_fill_over_empty_chunk() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = ChunkedArray::try_new( vec![ PrimitiveArray::from_option_iter(Vec::>::new()).into_array(), @@ -437,7 +440,7 @@ mod tests { #[test] fn evaluate_struct_field() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let test_array = StructArray::from_fields(&[( "a", PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]).into_array(), @@ -457,7 +460,7 @@ mod tests { #[test] fn evaluate_non_nullable_input() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let test_array = buffer![1i32, 2, 3].into_array(); let expr = fill_null(root(), lit(0i32)); let result = test_array.apply(&expr).unwrap(); @@ -468,7 +471,7 @@ mod tests { /// accepts, so adding a kernel without updating `supports_dtype` fails here. #[test] fn supports_dtype_matches_kernels() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let i32_dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let dtypes = [ DType::Bool(Nullability::Nullable), diff --git a/vortex-array/src/scalar_fn/fns/get_item.rs b/vortex-array/src/scalar_fn/fns/get_item.rs index e3f11af5ba1..663e3eebdbf 100644 --- a/vortex-array/src/scalar_fn/fns/get_item.rs +++ b/vortex-array/src/scalar_fn/fns/get_item.rs @@ -225,14 +225,16 @@ impl ScalarFnVTable for GetItem { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::GetItem; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Constant; use crate::arrays::ConstantArray; use crate::arrays::Filter; @@ -258,6 +260,8 @@ mod tests { use crate::scalar_fn::fns::get_item::StructArray; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn test_array() -> StructArray { StructArray::from_fields(&[ ("a", buffer![0i32, 1, 2].into_array()), @@ -280,7 +284,7 @@ mod tests { assert_arrays_eq!( item, buffer![0i32, 1, 2].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -312,7 +316,7 @@ mod tests { assert_arrays_eq!( item, PrimitiveArray::from_option_iter([None::]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -334,7 +338,7 @@ mod tests { assert_arrays_eq!( item, PrimitiveArray::from_option_iter([Some(1i32)]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -353,7 +357,7 @@ mod tests { (0..128).map(|idx| Scalar::primitive(idx, NonNullable)), ); let array = ConstantArray::new(scalar, 1_000_000).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let item: ArrayRef = GetItem::try_new(array, "f97")? .into_array() @@ -383,7 +387,7 @@ mod tests { assert_arrays_eq!( item, buffer![0i32, 2].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -400,7 +404,7 @@ mod tests { assert_arrays_eq!( item, buffer![1i32, 2].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -422,7 +426,7 @@ mod tests { assert_arrays_eq!( item, PrimitiveArray::from_option_iter([Some(0i32), None, Some(2)]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } @@ -502,7 +506,7 @@ mod tests { #[test] fn get_item_filter_list_field() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); use vortex_mask::Mask; use crate::arrays::BoolArray; @@ -539,10 +543,6 @@ mod tests { &mut ctx, ) .unwrap(); - assert_arrays_eq!( - result, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(result, expected, &mut SESSION.create_execution_ctx()); } } diff --git a/vortex-array/src/scalar_fn/fns/is_nan.rs b/vortex-array/src/scalar_fn/fns/is_nan.rs index 248bd91c2d4..c8059a4e6ab 100755 --- a/vortex-array/src/scalar_fn/fns/is_nan.rs +++ b/vortex-array/src/scalar_fn/fns/is_nan.rs @@ -48,11 +48,13 @@ impl RowFn for IsNan { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::Nullability; @@ -64,6 +66,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn dtype() { assert_eq!( @@ -117,7 +121,7 @@ mod tests { }; assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), expected_scalar ); @@ -140,7 +144,7 @@ mod tests { for (i, expected_value) in expected.iter().enumerate() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(*expected_value, Nullability::NonNullable) ); @@ -157,7 +161,7 @@ mod tests { for i in 0..result.len() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::null(DType::Bool(Nullability::Nullable)) ); @@ -188,7 +192,7 @@ mod tests { }; assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), expected_scalar ); @@ -216,7 +220,7 @@ mod tests { for (i, expected_value) in expected.iter().enumerate() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(*expected_value, Nullability::NonNullable) ); diff --git a/vortex-array/src/scalar_fn/fns/is_not_null.rs b/vortex-array/src/scalar_fn/fns/is_not_null.rs index 06f158b2adc..094510c8e41 100644 --- a/vortex-array/src/scalar_fn/fns/is_not_null.rs +++ b/vortex-array/src/scalar_fn/fns/is_not_null.rs @@ -195,7 +195,6 @@ mod tests { use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::StructArray; use crate::dtype::DType; @@ -222,6 +221,8 @@ mod tests { use crate::stats::all_null; use crate::stats::null_count; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + static STATS_SESSION: LazyLock = LazyLock::new(|| VortexSession::empty().with::()); @@ -298,7 +299,7 @@ mod tests { for (i, expected_value) in expected.iter().enumerate() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(*expected_value, Nullability::NonNullable) ); @@ -315,7 +316,7 @@ mod tests { for i in 0..result.len() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(true, Nullability::NonNullable) ); @@ -334,7 +335,7 @@ mod tests { for i in 0..result.len() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(false, Nullability::NonNullable) ); @@ -363,7 +364,7 @@ mod tests { for (i, expected_value) in expected.iter().enumerate() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(*expected_value, Nullability::NonNullable) ); diff --git a/vortex-array/src/scalar_fn/fns/is_null.rs b/vortex-array/src/scalar_fn/fns/is_null.rs index 566b1488c69..e0ccbf6942c 100644 --- a/vortex-array/src/scalar_fn/fns/is_null.rs +++ b/vortex-array/src/scalar_fn/fns/is_null.rs @@ -117,7 +117,6 @@ mod tests { use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::StructArray; use crate::dtype::DType; @@ -135,6 +134,8 @@ mod tests { use crate::stats::all_non_null; use crate::stats::null_count; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + static STATS_SESSION: LazyLock = LazyLock::new(|| VortexSession::empty().with::()); @@ -162,7 +163,7 @@ mod tests { for (i, expected_value) in expected.iter().enumerate() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(*expected_value, Nullability::NonNullable) ); @@ -180,7 +181,7 @@ mod tests { for i in 0..result.len() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(false, Nullability::NonNullable) ); @@ -200,7 +201,7 @@ mod tests { for i in 0..result.len() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(true, Nullability::NonNullable) ); @@ -229,7 +230,7 @@ mod tests { for (i, expected_value) in expected.iter().enumerate() { assert_eq!( result - .execute_scalar(i, &mut array_session().create_execution_ctx()) + .execute_scalar(i, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(*expected_value, Nullability::NonNullable) ); diff --git a/vortex-array/src/scalar_fn/fns/like/mod.rs b/vortex-array/src/scalar_fn/fns/like/mod.rs index b6f63a40eb7..13ddfb7d381 100644 --- a/vortex-array/src/scalar_fn/fns/like/mod.rs +++ b/vortex-array/src/scalar_fn/fns/like/mod.rs @@ -468,12 +468,13 @@ impl<'a> LikeVariant<'a> { #[cfg(test)] mod tests { use std::borrow::Cow; + use std::sync::LazyLock; use rstest::rstest; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::VarBinArray; @@ -493,6 +494,8 @@ mod tests { use crate::scalar_fn::fns::like::is_ascii; use crate::scalar_fn::fns::like::suffix_bytes_unchecked; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + const LONG: &str = "a value far too long to live inside its own view"; fn run_like( @@ -515,7 +518,7 @@ mod tests { #[case("%", [true, true, true, true])] #[case("_____", [true, true, false, true])] fn test_like_patterns(#[case] pattern: &str, #[case] expected: [bool; 4]) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["hello", "world", "help", "jello"]).into_array(); let result = run_like( @@ -528,7 +531,7 @@ mod tests { #[test] fn test_like_escapes() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["100%", "100x", "a_b", "axb"]).into_array(); let result = run_like( @@ -556,7 +559,7 @@ mod tests { #[test] fn test_like_regex_meta_characters_are_literal() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["a.c", "abc", "a$c"]).into_array(); let result = run_like( array, @@ -568,7 +571,7 @@ mod tests { #[test] fn test_like_unicode() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["h\u{00a3}llo", "hxllo", "h\u{00a3}xllo"]).into_array(); // `_` matches exactly one character of any byte width. @@ -582,7 +585,7 @@ mod tests { #[test] fn test_nlike() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["hello", "world"]).into_array(); let result = run_like( array, @@ -597,7 +600,7 @@ mod tests { #[test] fn test_ilike() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ilike = LikeOptions { negated: false, case_insensitive: true, @@ -616,7 +619,7 @@ mod tests { #[test] fn test_nilike() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["HELLO", "world"]).into_array(); let result = run_like( array, @@ -631,7 +634,7 @@ mod tests { #[test] fn test_like_nullable_input() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_nullable_str([Some("hello"), None, Some("help")]) .into_array(); let result = run_like( @@ -648,7 +651,7 @@ mod tests { #[test] fn test_like_null_pattern() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["hello", "world"]).into_array(); let result = run_like( array, @@ -660,7 +663,7 @@ mod tests { #[test] fn test_like_per_row_patterns() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinViewArray::from_iter_str(["hello", "hello", "hello"]).into_array(); let patterns = VarBinViewArray::from_iter_str(["he%", "%world", "h_llo"]).into_array(); let result = run_like(array, patterns, LikeOptions::default()); @@ -669,7 +672,7 @@ mod tests { #[test] fn test_like_non_canonical_input() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // VarBin (not the canonical VarBinView) is canonicalized before evaluation. let array = VarBinArray::from_iter( [Some("hello"), Some("world")], diff --git a/vortex-array/src/scalar_fn/fns/list_contains/mod.rs b/vortex-array/src/scalar_fn/fns/list_contains/mod.rs index b418f4d6774..e1206accf96 100644 --- a/vortex-array/src/scalar_fn/fns/list_contains/mod.rs +++ b/vortex-array/src/scalar_fn/fns/list_contains/mod.rs @@ -829,7 +829,6 @@ mod tests { use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -872,6 +871,8 @@ mod tests { use crate::stats::stat as stat_expr; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + static STATS_SESSION: LazyLock = LazyLock::new(|| VortexSession::empty().with::()); @@ -880,7 +881,7 @@ mod tests { } fn test_array() -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); ListArray::try_new( PrimitiveArray::from_iter(vec![1, 1, 2, 2, 2, 2, 2, 3, 3, 3]).into_array(), PrimitiveArray::from_iter(vec![0, 5, 10]).into_array(), @@ -899,12 +900,12 @@ mod tests { let item = arr.apply(&expr).unwrap(); assert_eq!( - item.execute_scalar(0, &mut array_session().create_execution_ctx()) + item.execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(true, Nullability::Nullable) ); assert_eq!( - item.execute_scalar(1, &mut array_session().create_execution_ctx()) + item.execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(false, Nullability::Nullable) ); @@ -918,12 +919,12 @@ mod tests { let item = arr.apply(&expr).unwrap(); assert_eq!( - item.execute_scalar(0, &mut array_session().create_execution_ctx()) + item.execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(true, Nullability::Nullable) ); assert_eq!( - item.execute_scalar(1, &mut array_session().create_execution_ctx()) + item.execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(true, Nullability::Nullable) ); @@ -937,12 +938,12 @@ mod tests { let item = arr.apply(&expr).unwrap(); assert_eq!( - item.execute_scalar(0, &mut array_session().create_execution_ctx()) + item.execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(false, Nullability::Nullable) ); assert_eq!( - item.execute_scalar(1, &mut array_session().create_execution_ctx()) + item.execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(false, Nullability::Nullable) ); @@ -950,7 +951,7 @@ mod tests { #[test] pub fn test_empty() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = ListArray::try_new( PrimitiveArray::from_iter(vec![1, 1, 2, 2, 2]).into_array(), PrimitiveArray::from_iter(vec![0, 5, 5]).into_array(), @@ -964,12 +965,12 @@ mod tests { let item = arr.apply(&expr).unwrap(); assert_eq!( - item.execute_scalar(0, &mut array_session().create_execution_ctx()) + item.execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(true, Nullability::Nullable) ); assert_eq!( - item.execute_scalar(1, &mut array_session().create_execution_ctx()) + item.execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(false, Nullability::Nullable) ); @@ -977,7 +978,7 @@ mod tests { #[test] pub fn test_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arr = ListArray::try_new( PrimitiveArray::from_iter(vec![1, 1, 2, 2, 2]).into_array(), PrimitiveArray::from_iter(vec![0, 5, 5]).into_array(), @@ -991,13 +992,13 @@ mod tests { let item = arr.apply(&expr).unwrap(); assert_eq!( - item.execute_scalar(0, &mut array_session().create_execution_ctx()) + item.execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(true, Nullability::Nullable) ); assert!( !item - .is_valid(1, &mut array_session().create_execution_ctx()) + .is_valid(1, &mut SESSION.create_execution_ctx()) .unwrap() ); } @@ -1092,7 +1093,7 @@ mod tests { let result = arr.clone().apply(&expr).unwrap(); assert_eq!( result - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(true, Nullability::NonNullable) ); @@ -1102,7 +1103,7 @@ mod tests { let result = arr.apply(&expr).unwrap(); assert_eq!( result - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::bool(false, Nullability::NonNullable) ); @@ -1110,7 +1111,7 @@ mod tests { #[test] fn test_null_in_empty_list() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = test_array(); let dtype = Arc::new(DType::Primitive(I32, Nullability::NonNullable)); @@ -1139,7 +1140,7 @@ mod tests { } fn nonnull_strings(values: Vec>) -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); ListArray::from_iter_slow::(values, Arc::new(DType::Utf8(Nullability::NonNullable))) .unwrap() @@ -1165,7 +1166,7 @@ mod tests { let elements = VarBinArray::from_iter(elements, DType::Utf8(Nullability::Nullable)).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); ListArray::try_new(elements, offsets, Validity::NonNullable, &mut ctx) .unwrap() @@ -1228,7 +1229,7 @@ mod tests { #[case] value: Option<&str>, #[case] expected: BoolArray, ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let element_nullability = list_array .dtype() .as_list_element_opt() @@ -1246,7 +1247,7 @@ mod tests { #[test] fn test_constant_list() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list_array = ConstantArray::new( Scalar::list( Arc::new(DType::Primitive(I32, Nullability::NonNullable)), @@ -1265,7 +1266,7 @@ mod tests { #[test] fn test_all_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list_array = ConstantArray::new( Scalar::null(DType::List( Arc::new(DType::Primitive(I32, Nullability::NonNullable)), @@ -1287,7 +1288,7 @@ mod tests { #[test] fn test_list_array_element() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list_scalar = Scalar::list( Arc::new(DType::Primitive(I32, Nullability::NonNullable)), vec![1.into(), 3.into(), 6.into()], @@ -1304,7 +1305,7 @@ mod tests { #[test] fn test_list_contains_empty_listview() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let empty_elements = PrimitiveArray::empty::(Nullability::NonNullable); let offsets = Buffer::from_iter([0u32, 0, 0, 0]).into_array(); let sizes = Buffer::from_iter([0u32, 0, 0, 0]).into_array(); @@ -1328,7 +1329,7 @@ mod tests { #[test] fn test_list_contains_all_null_elements() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_option_iter::([None, None, None, None, None]); let offsets = Buffer::from_iter([0u32, 2, 4]).into_array(); let sizes = Buffer::from_iter([2u32, 2, 1]).into_array(); @@ -1364,7 +1365,7 @@ mod tests { #[test] fn test_list_contains_large_offsets() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = Buffer::from_iter([1i32, 2, 3, 4, 5]).into_array(); let offsets = Buffer::from_iter([0u32, 1, 4, 0]).into_array(); @@ -1393,7 +1394,7 @@ mod tests { #[test] fn test_list_contains_offset_size_boundary() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = Buffer::from_iter(0..256).into_array(); let offsets = Buffer::from_iter([0u8, 100, 200, 254]).into_array(); let sizes = Buffer::from_iter([50u8, 50, 54, 2]).into_array(); @@ -1439,7 +1440,7 @@ mod tests { elements.into_array(), buffer![0u32, 1, 2, 3, 3].into_array(), Validity::AllValid, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )? .into_array(); assert_result( @@ -1458,7 +1459,7 @@ mod tests { buffer![1i32, 2].into_array(), buffer![0u32, 1, 2].into_array(), Validity::from(BitBuffer::from_iter([true, false])), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )? .into_array(); assert_result( @@ -1469,7 +1470,7 @@ mod tests { #[test] fn test_fold_sliced_match_bitmap() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bits = BitBuffer::from_iter([true, false, true, false]).slice(1..); let result = process_matches::( BoolArray::new(bits, Validity::NonNullable), @@ -1542,7 +1543,7 @@ mod tests { result: VortexResult, expected: impl IntoIterator>, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(result?, BoolArray::from_iter(expected), &mut ctx); Ok(()) } @@ -1629,7 +1630,7 @@ mod tests { ) -> VortexResult<()> { // Off SQL null semantics an empty list holds nothing to compare a null needle to; on them // the function is strict. Every evaluation path has to agree, a single row included. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let null = Scalar::null(DType::Primitive(I32, Nullability::Nullable)); let scalar = ConstantArray::new(null, 2) @@ -1666,7 +1667,7 @@ mod tests { PrimitiveArray::from_option_iter([Some(1i32)]).into_array(), PrimitiveArray::from_iter(vec![0, 1, 1, 1]).into_array(), Validity::from_iter([true, true, false]), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )? .into_array(); let null = Scalar::null(DType::Primitive(I32, Nullability::Nullable)); @@ -1678,7 +1679,7 @@ mod tests { /// Every row of `result` agrees with that row evaluated on its own, then matches `expected`. fn assert_rows_agree(result: ArrayRef, expected: BoolArray) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let whole = result.clone().execute::(&mut ctx)?.into_array(); for row in 0..result.len() { assert_eq!( @@ -1715,7 +1716,7 @@ mod tests { .into_array(), PrimitiveArray::from_iter(vec![0, 2, 2, 2, 4, 5, 6]).into_array(), Validity::from_iter([true, true, false, true, true, true]), - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )? .into_array(); let needles = @@ -1727,7 +1728,7 @@ mod tests { #[test] fn list_view_column_with_overlapping_views() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Views out of order and overlapping in `[1, 2, 3, 4]`: `[3, 4]` then `[1, 2, 3]`. let lists = ListViewArray::try_new( buffer![1i32, 2, 3, 4].into_array(), @@ -1762,7 +1763,7 @@ mod tests { .collect(), Nullability::NonNullable, ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = PrimitiveArray::from_iter(needles) .into_array() .apply(&list_contains(lit(list), root()))?; @@ -1803,7 +1804,7 @@ mod tests { let chunked = ChunkedArray::try_new(chunks, dtype)?.into_array(); let expr = list_contains_opts(lit(i32_set(vec![Some(2), None, Some(4)])), root(), options); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let flat = PrimitiveArray::from_option_iter([Some(1i32), None, Some(4), Some(2), None, Some(9)]) .into_array() @@ -1962,7 +1963,7 @@ mod tests { #[test] fn list_array_null_elements_under_sql_semantics() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Lists `[1, null]`, `[2]`, `[3]`, `[]` against a constant needle. let lists = ListArray::try_new( PrimitiveArray::from_option_iter([Some(1), None, Some(2), Some(3)]).into_array(), @@ -1990,7 +1991,7 @@ mod tests { #[test] fn scalar_needle_in_scalar_set_under_sql_semantics() -> VortexResult<()> { let set = i32_set(vec![Some(2), None]); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let hit = ConstantArray::new(Scalar::primitive(2i32, Nullability::Nullable), 1) .into_array() .apply(&in_list(root(), lit(set.clone())))?; @@ -2029,7 +2030,7 @@ mod tests { #[test] fn options_round_trip_through_serde() -> VortexResult<()> { use crate::scalar_fn::ScalarFnVTable; - let session = array_session(); + let session = VortexSession::empty(); for options in [ListContainsOptions::default(), SQL] { let bytes = ListContains .serialize(&options)? @@ -2118,7 +2119,7 @@ mod tests { ); assert_eq!(expr.optimize()?, expr); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let first = PrimitiveArray::from_option_iter([Some(1i32), Some(2), None]) .into_array() .apply_bound(&expr)?; diff --git a/vortex-array/src/scalar_fn/fns/list_contains/prepared/tests.rs b/vortex-array/src/scalar_fn/fns/list_contains/prepared/tests.rs index 6771a99aef2..fe3c6b46da6 100644 --- a/vortex-array/src/scalar_fn/fns/list_contains/prepared/tests.rs +++ b/vortex-array/src/scalar_fn/fns/list_contains/prepared/tests.rs @@ -1,18 +1,20 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::BitBuffer; use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_mask::Mask; +use vortex_session::VortexSession; use super::PreparedSet; use crate::ArrayRef; use crate::ExecutionCtx; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::Bool; use crate::arrays::BoolArray; use crate::arrays::Chunked; @@ -47,6 +49,8 @@ use crate::scalar_fn::fns::list_contains::ListContainsOptions; use crate::scalar_fn::fns::list_contains::PreparedSetData; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Prepares the non-null list scalar `list`. fn prepare(list: &Scalar) -> VortexResult { PreparedSetData::try_new(list.clone()) @@ -70,7 +74,7 @@ fn list_scalar(elements: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); ListArray::try_new( PrimitiveArray::from_option_iter([Some(1i32), None, Some(2), None, Some(9)]).into_array(), buffer![0u32, 2, 2, 4, 5].into_array(), @@ -82,7 +86,7 @@ fn nested_needles() -> ArrayRef { } fn map_needles() -> ArrayRef { - let ctx = array_session().create_execution_ctx(); + let ctx = SESSION.create_execution_ctx(); let dtype = DType::map( DType::Primitive(PType::I32, Nullability::NonNullable), DType::Utf8(Nullability::Nullable), @@ -124,7 +128,7 @@ fn test_row_set_returns_membership_bits( #[case] needles: ArrayRef, #[values(false, true)] sql_null_semantics: bool, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = needles.dtype().as_nullable(); // Unsorted, repeated members and a top-level null exercise normalization and SQL's // unknown non-match independently of any nulls nested inside the members. @@ -186,7 +190,7 @@ fn test_decimal_bitmap_across_storage_widths( needle_width: DecimalType, #[values(false, true)] sql_null_semantics: bool, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal = DecimalDType::new(precision, 1); let dtype = DType::Decimal(decimal, Nullability::Nullable); let mut elements: Vec<_> = [1i8, -2, 1] @@ -223,7 +227,7 @@ fn test_decimal_wide_values( #[case] base: i256, #[case] dense: bool, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let decimal = DecimalDType::new(precision, 2); let second = if dense { base + i256::ONE } else { -base }; let list = Scalar::list( @@ -285,7 +289,7 @@ fn test_primitive_integers( #[case] needles: ArrayRef, #[case] expected: [Option; 4], ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let set = PreparedSetData::try_new(list_scalar(&elements, &mut ctx)?)?; assert_arrays_eq!( set.contains(&needles, &ListContainsOptions::default(), &mut ctx)?, @@ -310,7 +314,7 @@ fn set_with_null() -> Scalar { #[test] fn test_prepared_set_rows_are_the_constant_list() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let set = prepare_array(&set_with_null(), 4)?; assert_arrays_eq!(set, ConstantArray::new(set_with_null(), 4), &mut ctx); @@ -340,7 +344,7 @@ fn test_list_contains_looks_up_in_a_prepared_set_list( #[case] options: ListContainsOptions, #[case] expected: [Option; 4], ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let set = prepare_array(&set_with_null(), 4)?; let needles = PrimitiveArray::from_option_iter([Some(1i32), Some(2), None, Some(3)]).into_array(); @@ -358,7 +362,7 @@ fn test_constant_needle_gives_a_constant( #[case] expected: Option, ) -> VortexResult<()> { // `3 IN (2, NULL)` against the prepared set is looked up once, and gives a constant. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let set = prepare_array(&set_with_null(), 4)?; let needle = ConstantArray::new(Scalar::primitive(3i32, Nullability::Nullable), 4).into_array(); @@ -376,7 +380,7 @@ fn test_constant_needle_gives_a_constant( #[test] fn test_constant_row_needle_looks_up_one_row() -> VortexResult<()> { // A row haystack cannot look a scalar needle up, so execution looks up one row. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let needles = nested_needles(); let dtype = needles.dtype().as_nullable(); let member = needles.execute_scalar(2, &mut ctx)?.cast(&dtype)?; @@ -402,7 +406,7 @@ fn test_result_from_bits_applies_null_semantics( #[case] expected: [Option; 3], ) -> VortexResult<()> { // Against `{2, null}`: a match, a non-match, and a null needle whose bit has no effect. - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let set = prepare(&set_with_null())?; let needle_dtype = DType::Primitive(PType::I32, Nullability::Nullable); let bits = BitBuffer::from_iter([true, false, true]); @@ -438,7 +442,7 @@ fn test_result_from_bits_rejects_mismatched_needles() -> VortexResult<()> { #[test] fn test_bytes_set_short_and_long_views() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = VarBinViewArray::from_iter_nullable_str([ Some("ab"), Some(""), @@ -524,7 +528,7 @@ fn test_constant_list_over_chunked_needles( #[case] options: ListContainsOptions, #[case] expected: [Option; 5], ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let needles = chunked_needles()?; let list = ConstantArray::new(set_with_null(), needles.len()).into_array(); @@ -540,7 +544,7 @@ fn test_constant_list_over_chunked_needles( #[test] fn test_optimized_expression_over_chunked_needles() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let needles = chunked_needles()?; let expr = list_contains(lit(set_with_null()), root()) .bind(needles.dtype())? diff --git a/vortex-array/src/scalar_fn/fns/list_length.rs b/vortex-array/src/scalar_fn/fns/list_length.rs index 67089fac221..f88e2baf80d 100644 --- a/vortex-array/src/scalar_fn/fns/list_length.rs +++ b/vortex-array/src/scalar_fn/fns/list_length.rs @@ -184,15 +184,16 @@ impl Matcher for AnyList { #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::FixedSizeListArray; @@ -209,6 +210,8 @@ mod tests { use crate::scalar::Scalar; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn create_list_elements() -> ArrayRef { PrimitiveArray::from_option_iter::([ Some(1), @@ -226,12 +229,12 @@ mod tests { #[case(buffer![0u32, 2, 5, 5, 7].into_array())] #[case(buffer![0u64, 2, 5, 5, 7].into_array())] fn test_list_length(#[case] offsets: ArrayRef) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let list = ListArray::try_new(elements, offsets, Validity::NonNullable, &mut ctx)?.into_array(); let result = list.apply(&list_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(result, PrimitiveArray::from_iter([2u64, 3, 0, 2]), &mut ctx); Ok(()) } @@ -240,7 +243,7 @@ mod tests { #[case(buffer![0u32, 2, 5, 5, 7].into_array())] #[case(buffer![0u64, 2, 5, 5, 7].into_array())] fn test_nullable_list_length(#[case] offsets: ArrayRef) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let list = ListArray::try_new( elements, @@ -251,7 +254,7 @@ mod tests { .into_array(); let result = list.apply(&list_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(2), None, Some(0), None]); @@ -269,7 +272,7 @@ mod tests { let array = ConstantArray::new(null_scalar, 2).into_array(); let result = array.apply(&list_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(!result.is_valid(0, &mut ctx)?); assert!(!result.is_valid(1, &mut ctx)?); assert_arrays_eq!( @@ -282,7 +285,7 @@ mod tests { #[test] fn test_listview_length() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let lv = ListViewArray::new( elements, @@ -293,14 +296,14 @@ mod tests { ) .into_array(); let result = lv.apply(&list_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(result, PrimitiveArray::from_iter([2u64, 3, 0, 2]), &mut ctx); Ok(()) } #[test] fn test_listview_length_nullable() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let lv = ListViewArray::new( elements, @@ -312,7 +315,7 @@ mod tests { .into_array(); let result = lv.apply(&list_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(2), None, Some(0), None]); assert_arrays_eq!(result, expected, &mut ctx); @@ -321,7 +324,7 @@ mod tests { #[test] fn test_list_length_take() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let list = ListArray::try_new( elements, @@ -333,7 +336,7 @@ mod tests { let taken = list.take(buffer![3u64, 0, 2].into_array())?; let result = taken.apply(&list_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(result, PrimitiveArray::from_iter([2u64, 2, 0]), &mut ctx); Ok(()) } @@ -349,7 +352,7 @@ mod tests { let fsl = create_fixed_size_list(Validity::NonNullable); let result = fsl.apply(&list_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(result, PrimitiveArray::from_iter([2u64, 2, 2, 2]), &mut ctx); Ok(()) } @@ -361,7 +364,7 @@ mod tests { )); let result = fsl.apply(&list_length(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(2), None, Some(2), None]); assert_arrays_eq!(result, expected, &mut ctx); @@ -381,7 +384,7 @@ mod tests { let lengths = fsl.apply(&list_length(cast(root(), failing_cast_dtype)))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = lengths.execute::(&mut ctx); assert!(result.is_err()); diff --git a/vortex-array/src/scalar_fn/fns/list_sum.rs b/vortex-array/src/scalar_fn/fns/list_sum.rs index 890f42a4cec..0e83a22ed3b 100644 --- a/vortex-array/src/scalar_fn/fns/list_sum.rs +++ b/vortex-array/src/scalar_fn/fns/list_sum.rs @@ -138,17 +138,18 @@ fn list_sum_impl( #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use prost::Message; use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; use crate::aggregate_fn::NumericalAggregateOpts; - use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::ConstantArray; use crate::arrays::FixedSizeListArray; @@ -170,6 +171,8 @@ mod tests { use crate::scalar_fn::fns::list_sum::ListSum; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn create_list_elements() -> ArrayRef { PrimitiveArray::from_option_iter::([ Some(1), @@ -187,12 +190,12 @@ mod tests { #[case(buffer![0u32, 2, 5, 5, 7].into_array())] #[case(buffer![0u64, 2, 5, 5, 7].into_array())] fn test_list_sum(#[case] offsets: ArrayRef) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let list = ListArray::try_new(elements, offsets, Validity::NonNullable, &mut ctx)?.into_array(); let result = list.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // [1, 2] = 3; [3, 4, 5] = 12; [] = null; [6, null] = 6 (nulls skipped). let expected = PrimitiveArray::from_option_iter::([Some(3), Some(12), None, Some(6)]); @@ -202,7 +205,7 @@ mod tests { #[test] fn test_nullable_list_sum() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let list = ListArray::try_new( elements, @@ -213,7 +216,7 @@ mod tests { .into_array(); let result = list.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Row 1 and 3 are null lists; row 2 is a valid but empty list. let expected = PrimitiveArray::from_option_iter::([Some(3), None, None, None]); assert_arrays_eq!(result, expected, &mut ctx); @@ -222,7 +225,7 @@ mod tests { #[test] fn test_all_null_elements_sum_to_null() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_option_iter::([None, None, Some(1)]); let list = ListArray::try_new( elements.into_array(), @@ -233,7 +236,7 @@ mod tests { .into_array(); let result = list.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([None, Some(1)]); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -241,7 +244,7 @@ mod tests { #[test] fn test_overflow_sums_to_null() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_iter([i64::MAX, 1, 1, 2]); let list = ListArray::try_new( elements.into_array(), @@ -252,7 +255,7 @@ mod tests { .into_array(); let result = list.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([None, Some(3)]); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -260,7 +263,7 @@ mod tests { #[test] fn test_unsigned_widening() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_iter([1u8, 2, 3]); let list = ListArray::try_new( elements.into_array(), @@ -271,7 +274,7 @@ mod tests { .into_array(); let result = list.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(6)]); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -279,7 +282,7 @@ mod tests { #[test] fn test_bool_elements() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = BoolArray::from_iter([true, true, false, true]); let list = ListArray::try_new( elements.into_array(), @@ -290,7 +293,7 @@ mod tests { .into_array(); let result = list.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(2), Some(1)]); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -298,7 +301,7 @@ mod tests { #[test] fn test_nan_skipped_by_default() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_iter([1.0f64, f64::NAN, 2.0]); let list = ListArray::try_new( elements.into_array(), @@ -309,7 +312,7 @@ mod tests { .into_array(); let result = list.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(3.0)]); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -317,7 +320,7 @@ mod tests { #[test] fn test_all_nan_list_sums_to_zero() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // NaN elements are *valid*: with the default `skip_nans` they contribute nothing, but // the list still has valid elements, so the sum is `0.0` rather than null (unlike an // all-null list). @@ -331,7 +334,7 @@ mod tests { .into_array(); let result = list.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(0.0)]); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -339,7 +342,7 @@ mod tests { #[test] fn test_nan_poisons_with_include_nans() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_iter([1.0f64, f64::NAN, 2.0]); let list = ListArray::try_new( elements.into_array(), @@ -353,7 +356,7 @@ mod tests { NumericalAggregateOpts::include_nans(), ))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(result.is_valid(0, &mut ctx)?); let result = result.execute::(&mut ctx)?; assert!(result.as_slice::()[0].is_nan()); @@ -362,7 +365,7 @@ mod tests { #[test] fn test_listview_sum() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); // Overlapping and out-of-order views over the shared elements. let lv = ListViewArray::new( @@ -375,7 +378,7 @@ mod tests { .into_array(); let result = lv.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // [6, null] = 6; [1, 2, 3] = 6; [] = null; [2, 3] = 5. let expected = PrimitiveArray::from_option_iter::([Some(6), Some(6), None, Some(5)]); @@ -394,7 +397,7 @@ mod tests { let fsl = create_fixed_size_list(Validity::NonNullable); let result = fsl.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(3), Some(7), Some(11), Some(15)]); assert_arrays_eq!(result, expected, &mut ctx); @@ -408,7 +411,7 @@ mod tests { )); let result = fsl.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(3), None, Some(11), None]); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -416,7 +419,7 @@ mod tests { #[test] fn test_list_sum_take() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let list = ListArray::try_new( elements, @@ -428,7 +431,7 @@ mod tests { let taken = list.take(buffer![3u64, 0, 2].into_array())?; let result = taken.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(6), Some(3), None]); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -436,7 +439,7 @@ mod tests { #[test] fn test_list_sum_slice() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let list = ListArray::try_new( elements, @@ -448,7 +451,7 @@ mod tests { let sliced = list.slice(1..4)?; let result = sliced.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter::([Some(12), None, Some(6)]); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -456,7 +459,7 @@ mod tests { #[test] fn test_empty_array() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = PrimitiveArray::from_iter([0i32; 0]); let list = ListArray::try_new( elements.into_array(), @@ -467,7 +470,7 @@ mod tests { .into_array(); let result = list.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( result, PrimitiveArray::from_option_iter::([]), @@ -478,7 +481,7 @@ mod tests { #[test] fn test_constant_list_sum() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = create_list_elements(); let list = ListArray::try_new( elements, @@ -487,7 +490,7 @@ mod tests { &mut ctx, )? .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scalar = list.execute_scalar(1, &mut ctx)?; let constant = ConstantArray::new(scalar, 3).into_array(); @@ -506,7 +509,7 @@ mod tests { let array = ConstantArray::new(null_scalar, 2).into_array(); let result = array.apply(&list_sum(root()))?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(!result.is_valid(0, &mut ctx)?); assert!(!result.is_valid(1, &mut ctx)?); assert_arrays_eq!( @@ -561,7 +564,7 @@ mod tests { let proto = expr.serialize_proto()?; let buf = proto.encode_to_vec(); let decoded = pb::Expr::decode(buf.as_slice())?; - let deser = Expression::from_proto(&decoded, &array_session())?; + let deser = Expression::from_proto(&decoded, &SESSION)?; assert_eq!(expr, deser); } Ok(()) diff --git a/vortex-array/src/scalar_fn/fns/mask/kernel.rs b/vortex-array/src/scalar_fn/fns/mask/kernel.rs index a35f6a42300..b03c2dd5509 100644 --- a/vortex-array/src/scalar_fn/fns/mask/kernel.rs +++ b/vortex-array/src/scalar_fn/fns/mask/kernel.rs @@ -127,9 +127,12 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayEq; use crate::ArrayRef; @@ -152,6 +155,8 @@ mod tests { use crate::scalar_fn::fns::operators::Operator; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn lazy_mask() -> VortexResult { Binary::try_new( BoolArray::from_iter([true, true, false]).into_array(), @@ -182,7 +187,7 @@ mod tests { }; assert!(ArrayRef::ptr_eq(&validity, &mask)); - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( output, PrimitiveArray::from_option_iter([Some(1i32), None, None]), @@ -201,7 +206,7 @@ mod tests { let output = input.mask(lazy_mask()?)?; assert!(output.is::>()); - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( output, PrimitiveArray::from_option_iter([all_true.then_some(1i32), None, None]), @@ -243,7 +248,7 @@ mod tests { optimized.encoding_id() ); - let mut ctx = crate::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = if mask_value { PrimitiveArray::from_option_iter([Some(1i32), Some(2), Some(3), Some(4), Some(5)]) } else { diff --git a/vortex-array/src/scalar_fn/fns/merge.rs b/vortex-array/src/scalar_fn/fns/merge.rs index 53bfd3984ed..4913b120000 100644 --- a/vortex-array/src/scalar_fn/fns/merge.rs +++ b/vortex-array/src/scalar_fn/fns/merge.rs @@ -254,14 +254,16 @@ impl Display for DuplicateHandling { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::struct_::StructArrayExt; use crate::assert_arrays_eq; @@ -280,8 +282,10 @@ mod tests { use crate::scalar_fn::fns::merge::StructArray; use crate::scalar_fn::fns::pack::Pack; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn field_array(array: &ArrayRef, field_path: &[&str]) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut field_path = field_path.iter(); let Some(field) = field_path.next() else { @@ -306,7 +310,7 @@ mod tests { #[test] pub fn test_merge_right_most() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expr = merge_opts( vec![ get_item("0", root()), @@ -443,11 +447,7 @@ mod tests { crate::validity::Validity::NonNullable, ) .unwrap(); - assert_arrays_eq!( - actual_array, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(actual_array, expected, &mut SESSION.create_execution_ctx()); } #[test] @@ -488,7 +488,7 @@ mod tests { ]) .unwrap() .into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual_array = test_array .apply(&expr) .unwrap() @@ -515,7 +515,7 @@ mod tests { #[test] pub fn test_merge_order() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expr = merge(vec![get_item("0", root()), get_item("1", root())]); let test_array = StructArray::from_fields(&[ diff --git a/vortex-array/src/scalar_fn/fns/not/mod.rs b/vortex-array/src/scalar_fn/fns/not/mod.rs index 4c00feef9ad..b4c0c1b3bb5 100644 --- a/vortex-array/src/scalar_fn/fns/not/mod.rs +++ b/vortex-array/src/scalar_fn/fns/not/mod.rs @@ -122,11 +122,13 @@ impl ScalarFnVTable for Not { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::assert_arrays_eq; use crate::dtype::DType; use crate::dtype::Nullability; @@ -137,6 +139,8 @@ mod tests { use crate::expr::test_harness; use crate::scalar_fn::fns::not::BoolArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn is_strict() { assert!( @@ -148,7 +152,7 @@ mod tests { #[test] fn preserves_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = BoolArray::from_iter([Some(false), None, Some(true)]).into_array(); let result = input.apply(¬(root()))?; @@ -163,7 +167,7 @@ mod tests { #[test] fn invert_booleans() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let not_expr = not(root()); let bools = BoolArray::from_iter([false, true, false, false, true, true]); let result = bools.into_array().apply(¬_expr).unwrap(); diff --git a/vortex-array/src/scalar_fn/fns/pack.rs b/vortex-array/src/scalar_fn/fns/pack.rs index f51b34482d5..c9e5a60ec3a 100644 --- a/vortex-array/src/scalar_fn/fns/pack.rs +++ b/vortex-array/src/scalar_fn/fns/pack.rs @@ -163,16 +163,18 @@ impl ScalarFnVTable for Pack { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; + use vortex_session::VortexSession; use super::Pack; use super::PackOptions; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::arrays::struct_::StructArrayExt; use crate::assert_arrays_eq; @@ -183,6 +185,8 @@ mod tests { use crate::scalar_fn::fns::pack::StructArray; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn test_array() -> ArrayRef { StructArray::from_fields(&[ ("a", buffer![0, 1, 2].into_array()), @@ -193,7 +197,7 @@ mod tests { } fn field_array(array: &ArrayRef, field_path: &[&str]) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut field_path = field_path.iter(); let Some(field) = field_path.next() else { @@ -218,7 +222,7 @@ mod tests { #[test] pub fn test_empty_pack() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expr = Pack.new_expr( PackOptions { names: Default::default(), @@ -240,7 +244,7 @@ mod tests { #[test] pub fn test_simple_pack() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expr = Pack.new_expr( PackOptions { names: ["one", "two", "three"].into(), @@ -277,7 +281,7 @@ mod tests { #[test] pub fn test_nested_pack() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expr = Pack.new_expr( PackOptions { names: ["one", "two", "three"].into(), @@ -328,7 +332,7 @@ mod tests { #[test] pub fn test_pack_nullable() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expr = Pack.new_expr( PackOptions { names: ["one", "two", "three"].into(), diff --git a/vortex-array/src/scalar_fn/fns/replace_time_zone.rs b/vortex-array/src/scalar_fn/fns/replace_time_zone.rs index 658a04e021c..a07029cfe70 100644 --- a/vortex-array/src/scalar_fn/fns/replace_time_zone.rs +++ b/vortex-array/src/scalar_fn/fns/replace_time_zone.rs @@ -313,6 +313,8 @@ fn replace( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_error::VortexResult; use vortex_error::vortex_err; @@ -324,7 +326,6 @@ mod tests { use super::resolve_zone; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ExtensionArray; use crate::arrays::PrimitiveArray; use crate::arrays::StructArray; @@ -343,6 +344,8 @@ mod tests { use crate::scalar_fn::ScalarFnVTable; use crate::scalar_fn::fns::literal::Literal; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(TimeUnit::Seconds, 1)] #[case(TimeUnit::Milliseconds, 1_000)] @@ -437,10 +440,7 @@ mod tests { null_on_non_existent, }; let metadata = ReplaceTimeZone.serialize(&options)?.unwrap(); - assert_eq!( - ReplaceTimeZone.deserialize(&metadata, &VortexSession::empty())?, - options - ); + assert_eq!(ReplaceTimeZone.deserialize(&metadata, &SESSION)?, options); Ok(()) } @@ -547,7 +547,7 @@ mod tests { ]) .into_array(), ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) } diff --git a/vortex-array/src/scalar_fn/fns/select.rs b/vortex-array/src/scalar_fn/fns/select.rs index c73aeb8e545..e410105d1b4 100644 --- a/vortex-array/src/scalar_fn/fns/select.rs +++ b/vortex-array/src/scalar_fn/fns/select.rs @@ -346,13 +346,15 @@ impl Display for FieldSelection { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Constant; use crate::arrays::ConstantArray; use crate::arrays::ScalarFnArray; @@ -374,6 +376,8 @@ mod tests { use crate::scalar_fn::fns::select::Select; use crate::scalar_fn::fns::select::StructArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn test_array() -> StructArray { StructArray::from_fields(&[ ("a", buffer![0, 1, 2].into_array()), @@ -384,7 +388,7 @@ mod tests { #[test] pub fn include_columns() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let st = test_array(); let select = select(vec![FieldName::from("a")], root()); let selected = st.into_array().apply(&select).unwrap(); @@ -399,7 +403,7 @@ mod tests { #[test] pub fn exclude_columns() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let st = test_array(); let select = select_exclude(vec![FieldName::from("a")], root()); let selected = st.into_array().apply(&select).unwrap(); @@ -484,7 +488,7 @@ mod tests { (0..128).map(Scalar::from), ); let array = ConstantArray::new(scalar, 1_000_000).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let item: ArrayRef = ScalarFnArray::try_new( Select.bind(FieldSelection::Include(FieldNames::from(["f97", "f3"]))), diff --git a/vortex-array/src/scalar_fn/fns/variant_get/mod.rs b/vortex-array/src/scalar_fn/fns/variant_get/mod.rs index 1d0af15a6b2..ef493d0146e 100644 --- a/vortex-array/src/scalar_fn/fns/variant_get/mod.rs +++ b/vortex-array/src/scalar_fn/fns/variant_get/mod.rs @@ -409,6 +409,8 @@ impl From for VariantPathElement { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; @@ -419,7 +421,6 @@ mod tests { use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Chunked; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -446,6 +447,8 @@ mod tests { use crate::scalar_fn::fns::variant_get::VariantPath; use crate::scalar_fn::fns::variant_get::VariantPathElement; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn variant_object(fields: impl IntoIterator) -> Scalar { let fields = fields.into_iter().collect::>(); let names = FieldNames::from_iter(fields.iter().map(|(name, _)| FieldName::from(*name))); @@ -561,7 +564,7 @@ mod tests { let expr = variant_get(root(), parse_path(path)?, dtype); array .apply(&expr)? - .execute::(&mut array_session().create_execution_ctx()) + .execute::(&mut SESSION.create_execution_ctx()) } #[test] @@ -634,9 +637,7 @@ mod tests { Some(DType::Primitive(PType::I32, Nullability::NonNullable)), ); let metadata = VariantGet.serialize(&options).unwrap().unwrap(); - let actual = VariantGet - .deserialize(&metadata, &VortexSession::empty()) - .unwrap(); + let actual = VariantGet.deserialize(&metadata, &SESSION).unwrap(); assert_eq!(actual, options); } @@ -649,7 +650,7 @@ mod tests { Some(DType::Primitive(PType::I32, Nullability::NonNullable)), ); let proto = expr.serialize_proto().unwrap(); - let actual = Expression::from_proto(&proto, &array_session()).unwrap(); + let actual = Expression::from_proto(&proto, &SESSION).unwrap(); assert_eq!(actual, expr); } @@ -691,7 +692,7 @@ mod tests { "$.items[1]", Some(DType::Primitive(PType::I32, Nullability::NonNullable)), )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( result, @@ -725,7 +726,7 @@ mod tests { "$.a", Some(DType::Primitive(PType::I32, Nullability::NonNullable)), )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( result, @@ -759,7 +760,7 @@ mod tests { )?; assert!(!result.is::()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( result, PrimitiveArray::from_option_iter([Some(10i32), Some(20), None]), @@ -785,7 +786,7 @@ mod tests { let result = execute_variant_get(array, "$.a", None)?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let row0 = result.execute_scalar(0, &mut ctx)?; assert_eq!( row0.as_variant() @@ -822,8 +823,8 @@ mod tests { let result = execute_variant_get(array, "$.a", None)?; let variant = result .clone() - .execute::(&mut array_session().create_execution_ctx())?; - let canonical = result.execute::(&mut array_session().create_execution_ctx())?; + .execute::(&mut SESSION.create_execution_ctx())?; + let canonical = result.execute::(&mut SESSION.create_execution_ctx())?; let Canonical::Variant(canonical_variant) = canonical else { vortex_bail!("expected Variant canonical array"); }; @@ -833,7 +834,7 @@ mod tests { assert_eq!(variant.core_storage().dtype(), variant.dtype()); assert_eq!(variant.core_storage().len(), variant.len()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for array in [variant, canonical_variant] { assert_eq!(array.dtype(), &DType::Variant(Nullability::Nullable)); for (idx, expected) in [10i32, 20].into_iter().enumerate() { diff --git a/vortex-array/src/scalar_fn/fns/zip/mod.rs b/vortex-array/src/scalar_fn/fns/zip/mod.rs index d1d57d5b814..fa46512a4f0 100644 --- a/vortex-array/src/scalar_fn/fns/zip/mod.rs +++ b/vortex-array/src/scalar_fn/fns/zip/mod.rs @@ -342,14 +342,16 @@ pub(crate) fn zip_validity( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::ConstantArray; use crate::arrays::PrimitiveArray; use crate::arrays::Struct; @@ -370,6 +372,8 @@ mod tests { use crate::expr::zip_expr; use crate::scalar::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn dtype() { let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); @@ -389,7 +393,7 @@ mod tests { #[test] fn test_zip_basic() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mask = Mask::from_iter([true, false, false, true, false]); let if_true = buffer![10, 20, 30, 40, 50].into_array(); let if_false = buffer![1, 2, 3, 4, 5].into_array(); @@ -402,7 +406,7 @@ mod tests { #[test] fn test_zip_all_true() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mask = Mask::new_true(4); let if_true = buffer![10, 20, 30, 40].into_array(); let if_false = @@ -418,7 +422,7 @@ mod tests { #[test] fn test_zip_all_false_widens_nullability() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mask = Mask::new_false(4); let if_true = PrimitiveArray::from_option_iter([Some(10), Some(20), Some(30), None]).into_array(); @@ -466,7 +470,7 @@ mod tests { let mask = Mask::from_indices(len, indices); let mask_array = mask.into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = mask_array .zip(const1.clone(), const2.clone())? .execute::(&mut ctx)? @@ -542,7 +546,7 @@ mod tests { let mask = Mask::from_indices(200, (0..100).filter(|i| i % 3 != 0)); let mask_array = mask.clone().into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let zipped = mask_array .zip(if_true, if_false) .unwrap() diff --git a/vortex-array/src/scalar_fn/unstable/row/batch/tests.rs b/vortex-array/src/scalar_fn/unstable/row/batch/tests.rs index 1aa7ee43bbf..532bd30a6f7 100644 --- a/vortex-array/src/scalar_fn/unstable/row/batch/tests.rs +++ b/vortex-array/src/scalar_fn/unstable/row/batch/tests.rs @@ -3,6 +3,7 @@ use std::mem::MaybeUninit; use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; @@ -14,6 +15,7 @@ use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; use vortex_error::vortex_err; +use vortex_session::VortexSession; use vortex_session::registry::CachedId; use super::finalize_kernel_output; @@ -21,7 +23,6 @@ use crate::ArrayRef; use crate::ExecutionCtx; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::BoolArray; use crate::arrays::Constant; use crate::arrays::ConstantArray; @@ -58,6 +59,8 @@ use crate::scalar_fn::unstable::row::execute_rows; use crate::scalar_fn::unstable::row::row_fn_return_dtype; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[derive(Clone, Default)] struct DeferredAdd { /// The number of preparations across the dense attempt and any valid-row retry. @@ -555,7 +558,7 @@ fn test_fixed_size_list_sink_uses_runtime_width( let row_count = input_values.len(); let input = PrimitiveArray::new(input_values, validity.clone()).into_array(); let args = VecExecutionArgs::new(vec![input], row_count); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&RepeatValue, &width, &args, &mut ctx)?; let expected = FixedSizeListArray::new( @@ -702,7 +705,7 @@ fn test_finalize_kernel_output_rejects_nested_dtype_mismatch() -> VortexResult<( Arc::new(DType::Primitive(i64::PTYPE, Nullability::Nullable)), Nullability::NonNullable, ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = finalize_kernel_output(*ID, &result_dtype, 2, values, &mut ctx) .expect_err("nested nullability mismatch must fail output validation"); @@ -719,7 +722,7 @@ fn test_finalize_kernel_output_rejects_nested_dtype_mismatch() -> VortexResult<( fn test_kernel_output_rejects_nulls_at_function_boundary() -> VortexResult<()> { let input = PrimitiveArray::new(vec![1_i64, 2], Validity::NonNullable).into_array(); let args = VecExecutionArgs::new(vec![input], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let execution = execute_rows(&InvalidKernelOutput, &EmptyOptions, &args, &mut ctx); let error = match execution { Err(error) => error, @@ -749,7 +752,7 @@ fn test_bool_output_builds_packed_values() -> VortexResult<()> { ) .into_array(); let args = VecExecutionArgs::new(vec![input], 5); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&PackedPositive, &EmptyOptions, &args, &mut ctx)?; let expected = @@ -770,7 +773,7 @@ fn test_bool_output_word_boundaries(#[case] len: usize) -> VortexResult<()> { let values: Vec<_> = (0..len).map(|index| index as i64 - 32).collect(); let input = PrimitiveArray::from_iter(values.iter().copied()).into_array(); let args = VecExecutionArgs::new(vec![input], len); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&PackedPositive, &EmptyOptions, &args, &mut ctx)?; let expected = BoolArray::from_iter(values.iter().map(|value| *value > 0)).into_array(); @@ -783,7 +786,7 @@ fn assert_bool_output_handles_partial_constants() -> let values: Vec<_> = (0_i64..65).collect(); let varying = PrimitiveArray::from_iter(values.iter().copied()).into_array(); let constant = ConstantArray::new(32_i64, values.len()).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let function = PackedGreaterThan::; let lhs_varying = VecExecutionArgs::new(vec![varying.clone(), constant.clone()], values.len()); @@ -809,7 +812,7 @@ fn test_bool_output_handles_partial_constants() -> VortexResult<()> { fn test_bool_output_handles_all_constant_input() -> VortexResult<()> { let input = ConstantArray::new(7_i64, 65).into_array(); let args = VecExecutionArgs::new(vec![input], 65); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&PackedPositive, &EmptyOptions, &args, &mut ctx)?; let expected = BoolArray::from_iter(std::iter::repeat_n(true, 65)).into_array(); @@ -821,7 +824,7 @@ fn test_bool_output_handles_all_constant_input() -> VortexResult<()> { #[test] fn test_bool_output_handles_nullary_rows() -> VortexResult<()> { let args = VecExecutionArgs::new(vec![], 65); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&NullaryTrue, &EmptyOptions, &args, &mut ctx)?; let expected = BoolArray::from_iter(std::iter::repeat_n(true, 65)).into_array(); @@ -838,7 +841,7 @@ fn test_valid_only_bool_output_skips_invalid_rows() -> VortexResult<()> { ) .into_array(); let args = VecExecutionArgs::new(vec![input], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&ValidOnlyPositive, &EmptyOptions, &args, &mut ctx)?; let expected = BoolArray::from_iter([Some(true), None, Some(false)]).into_array(); @@ -853,7 +856,7 @@ fn test_filtered_execution_skips_invalid_decode_payloads() -> VortexResult<()> { let input = PrimitiveArray::new(vec![i64::MIN, 10, i64::MIN, 30], validity.clone()).into_array(); let args = VecExecutionArgs::new(vec![input], 4); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&FilteredIdentity, &EmptyOptions, &args, &mut ctx)?; let expected = PrimitiveArray::new(vec![0_i64, 10, 0, 30], validity).into_array(); @@ -872,7 +875,7 @@ fn test_filtered_execution_preserves_runtime_sink_params( let validity = Validity::from_iter([false, true]); let input = PrimitiveArray::new(vec![i64::MIN, 7], validity.clone()).into_array(); let args = VecExecutionArgs::new(vec![input], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&FilteredRepeat, &width, &args, &mut ctx)?; let expected = FixedSizeListArray::new( @@ -894,7 +897,7 @@ fn test_deferred_bool_output_builds_packed_values() -> VortexResult<()> { let lhs = PrimitiveArray::from_iter(values.iter().copied()).into_array(); let rhs = PrimitiveArray::from_iter(std::iter::repeat_n(32_i64, values.len())).into_array(); let args = VecExecutionArgs::new(vec![lhs, rhs], values.len()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&DeferredGreaterThan::, &EmptyOptions, &args, &mut ctx)?; let expected = BoolArray::from_iter(values.iter().map(|value| *value > 32)).into_array(); @@ -908,7 +911,7 @@ fn test_deferred_bool_output_handles_partial_constants() -> VortexResult<()> { let values: Vec<_> = (0_i64..65).collect(); let varying = PrimitiveArray::from_iter(values.iter().copied()).into_array(); let constant = ConstantArray::new(32_i64, values.len()).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let function = DeferredGreaterThan::; let lhs_varying = VecExecutionArgs::new(vec![varying.clone(), constant.clone()], values.len()); @@ -969,7 +972,7 @@ fn test_deferred_bool_sliced_validity_and_constants( BooleanInputShape::ConstantRhs => (varying, constant), }; let args = VecExecutionArgs::new(vec![lhs, rhs], len); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = if multiversioned { execute_rows(&DeferredGreaterThan::, &EmptyOptions, &args, &mut ctx)? } else { @@ -1003,7 +1006,7 @@ fn test_deferred_bool_decode_error_is_terminal() { ) .into_array(); let args = VecExecutionArgs::new(vec![input], 1); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_bool_dense_attempt::<(Utf8Column,), (), bool, true>( &args, @@ -1023,7 +1026,7 @@ fn test_deferred_bool_output_reports_valid_row_failure() -> VortexResult<()> { let lhs = PrimitiveArray::from_iter([1_i64, i64::MIN, -1]).into_array(); let rhs = ConstantArray::new(0_i64, 3).into_array(); let args = VecExecutionArgs::new(vec![lhs, rhs], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = match execute_rows(&DeferredGreaterThan::, &EmptyOptions, &args, &mut ctx) { Err(error) => error.to_string(), @@ -1042,7 +1045,7 @@ fn test_deferred_owned_execution_handles_constant_lhs() -> VortexResult<()> { let lhs = ConstantArray::new(10_i64, 3).into_array(); let rhs = PrimitiveArray::from_iter([1_i64, 2, 3]).into_array(); let args = VecExecutionArgs::new(vec![lhs, rhs], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&DeferredAdd::default(), &EmptyOptions, &args, &mut ctx)?; let expected = PrimitiveArray::from_iter([11_i64, 12, 13]).into_array(); @@ -1059,7 +1062,7 @@ fn test_deferred_owned_execution_retries_null_row_failure() -> VortexResult<()> let rhs = ConstantArray::new(1_i64, 2).into_array(); let args = VecExecutionArgs::new(vec![lhs, rhs], 2); let (allocator, tracker) = tracking_allocator(); - let mut ctx = array_session() + let mut ctx = VortexSession::empty() .create_execution_ctx() .with_allocator(allocator); @@ -1079,7 +1082,7 @@ fn test_dense_retry_filters_when_direct_valid_rows_are_unavailable() -> VortexRe let validity = Validity::from_iter([true, false, true]); let input = PrimitiveArray::new(vec![1_i64, i64::MAX, 3], validity.clone()).into_array(); let args = VecExecutionArgs::new(vec![input], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&DenseRetryIncrement, &EmptyOptions, &args, &mut ctx)?; let expected = PrimitiveArray::new(vec![2_i64, 0, 4], validity).into_array(); @@ -1095,7 +1098,7 @@ fn test_deferred_owned_execution_does_not_retry_partially_valid_success() -> Vor let lhs = PrimitiveArray::new(vec![1_i64, 2], validity.clone()).into_array(); let rhs = ConstantArray::new(1_i64, 2).into_array(); let args = VecExecutionArgs::new(vec![lhs, rhs], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&function, &EmptyOptions, &args, &mut ctx)?; let expected = PrimitiveArray::new(vec![2_i64, 0], validity).into_array(); @@ -1112,7 +1115,7 @@ fn test_deferred_owned_execution_retries_and_reports_valid_row_failure() -> Vort let lhs = PrimitiveArray::new(vec![i64::MAX, 1], validity).into_array(); let rhs = ConstantArray::new(1_i64, 2).into_array(); let args = VecExecutionArgs::new(vec![lhs, rhs], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = execute_rows(&function, &EmptyOptions, &args, &mut ctx) .expect_err("a valid-row overflow must remain observable"); @@ -1133,7 +1136,7 @@ fn test_deferred_owned_array_backed_all_valid_error_does_not_retry() -> VortexRe let lhs = PrimitiveArray::new(vec![i64::MAX, 1], validity).into_array(); let rhs = ConstantArray::new(1_i64, 2).into_array(); let args = VecExecutionArgs::new(vec![lhs, rhs], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = execute_rows(&function, &EmptyOptions, &args, &mut ctx) .expect_err("an all-valid deferred error must remain observable"); @@ -1151,7 +1154,7 @@ fn test_deferred_owned_array_backed_all_valid_error_does_not_retry() -> VortexRe fn test_valid_only_empty_batch_preserves_nonnullable_dtype() -> VortexResult<()> { let input = PrimitiveArray::from_iter(std::iter::empty::()).into_array(); let args = VecExecutionArgs::new(vec![input], 0); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&ValidOnlyIdentity, &EmptyOptions, &args, &mut ctx)?; @@ -1292,7 +1295,7 @@ fn test_declared_output_dtype_labels_batch(#[case] validity: Validity) -> Vortex let values = vec![1_i64, 2, 3]; let input = PrimitiveArray::new(values.clone(), validity.clone()).into_array(); let args = VecExecutionArgs::new(vec![input], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows( &DeclaredOutput::timestamps(), @@ -1313,7 +1316,7 @@ fn test_declared_output_dtype_labels_sink_output(#[case] validity: Validity) -> let values = vec![1_i64, 2, 3]; let input = PrimitiveArray::new(values.clone(), validity.clone()).into_array(); let args = VecExecutionArgs::new(vec![input], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&DeclaredSinkOutput, &EmptyOptions, &args, &mut ctx)?; let expected = expected_timestamps(values, validity)?; @@ -1326,7 +1329,7 @@ fn test_declared_output_dtype_labels_sink_output(#[case] validity: Validity) -> fn test_declared_output_dtype_labels_empty_batch() -> VortexResult<()> { let input = PrimitiveArray::from_iter(std::iter::empty::()).into_array(); let args = VecExecutionArgs::new(vec![input], 0); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows( &DeclaredOutput::timestamps(), @@ -1345,7 +1348,7 @@ fn test_declared_output_dtype_labels_all_null_batch() -> VortexResult<()> { let null_i64 = Scalar::null(DType::Primitive(i64::PTYPE, Nullability::Nullable)); let input = ConstantArray::new(null_i64, 3).into_array(); let args = VecExecutionArgs::new(vec![input], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows( &DeclaredOutput::timestamps(), @@ -1364,7 +1367,7 @@ fn test_declared_output_dtype_labels_all_null_batch() -> VortexResult<()> { fn test_declared_output_dtype_labels_constant_batch() -> VortexResult<()> { let input = ConstantArray::new(7_i64, 3).into_array(); let args = VecExecutionArgs::new(vec![input], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows( &DeclaredOutput::timestamps(), @@ -1400,7 +1403,7 @@ fn test_declared_output_dtype_rejects_bad_label( }; let input = PrimitiveArray::from_iter(vec![1_i64, 2]).into_array(); let args = VecExecutionArgs::new(vec![input], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = execute_rows(&function, &EmptyOptions, &args, &mut ctx) .expect_err("an invalid output dtype must be rejected") @@ -1444,7 +1447,7 @@ impl RowFn for MismatchedStorage { fn test_declared_output_dtype_rejects_mismatched_storage() -> VortexResult<()> { let input = PrimitiveArray::from_iter(vec![1_u64, 2]).into_array(); let args = VecExecutionArgs::new(vec![input], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = execute_rows(&MismatchedStorage, &EmptyOptions, &args, &mut ctx) .expect_err("an extension label over another storage dtype must be rejected") @@ -1464,7 +1467,7 @@ fn test_execution_rejects_a_changed_output_dtype() -> VortexResult<()> { }; let input = PrimitiveArray::from_iter(vec![1_i64, 2]).into_array(); let args = VecExecutionArgs::new(vec![input], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = execute_rows(&function, &EmptyOptions, &args, &mut ctx) .expect_err("an execution dispatch must declare the planned output dtype") @@ -1483,7 +1486,7 @@ fn test_undeclared_output_dtype_keeps_the_storage_dtype() -> VortexResult<()> { let values = vec![1_i64, 2]; let input = PrimitiveArray::from_iter(values.clone()).into_array(); let args = VecExecutionArgs::new(vec![input], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&function, &EmptyOptions, &args, &mut ctx)?; let expected = PrimitiveArray::from_iter(values).into_array(); @@ -1523,7 +1526,7 @@ fn constant_output_retains_execution_allocator_payload() -> VortexResult<()> { let input = ConstantArray::new(1_i64, 3).into_array(); let args = VecExecutionArgs::new(vec![input], 3); let (allocator, tracker) = tracking_allocator(); - let mut ctx = array_session() + let mut ctx = VortexSession::empty() .create_execution_ctx() .with_allocator(allocator); diff --git a/vortex-array/src/scalar_fn/unstable/row/execute/sink.rs b/vortex-array/src/scalar_fn/unstable/row/execute/sink.rs index 133d131aeca..b964cbb737e 100644 --- a/vortex-array/src/scalar_fn/unstable/row/execute/sink.rs +++ b/vortex-array/src/scalar_fn/unstable/row/execute/sink.rs @@ -336,22 +336,26 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_mask::Mask; + use vortex_session::VortexSession; use super::execute_sink_valid_rows; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::NativePType; use crate::scalar_fn::VecExecutionArgs; use crate::scalar_fn::unstable::row::OutputSink; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + struct ShrinkingSink(Vec); // SAFETY: the initializer deliberately shrinks the row collection to exercise the executor's @@ -399,7 +403,7 @@ mod tests { let Mask::Values(valid) = Mask::from_iter([false, true]) else { vortex_bail!("the test validity must be partially valid"); }; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = execute_sink_valid_rows::<(i64,), (), ShrinkingSink, ()>( &args, diff --git a/vortex-array/src/scalar_fn/unstable/row/execute/tests.rs b/vortex-array/src/scalar_fn/unstable/row/execute/tests.rs index 40ab20e255e..3fd72339f4d 100644 --- a/vortex-array/src/scalar_fn/unstable/row/execute/tests.rs +++ b/vortex-array/src/scalar_fn/unstable/row/execute/tests.rs @@ -13,6 +13,7 @@ use vortex_error::vortex_bail; use vortex_error::vortex_err; use vortex_mask::Mask; use vortex_mask::MaskValuesRef; +use vortex_session::VortexSession; use super::DenseAttempt; use super::execute_bool_dense_attempt; @@ -30,7 +31,6 @@ use crate::ArrayRef; use crate::ExecutionCtx; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::Bool; use crate::arrays::ConstantArray; use crate::arrays::FixedSizeList; @@ -153,7 +153,7 @@ fn owned_payload_uses_context_allocator( let valid = selected_rows(); let (session_allocator, session_tracker) = tracking_allocator(); let (allocator, tracker) = tracking_allocator(); - let mut ctx = array_session() + let mut ctx = VortexSession::empty() .with_allocator(session_allocator) .create_execution_ctx() .with_allocator(allocator); @@ -185,7 +185,7 @@ fn packed_boolean_payload_uses_allocator( ) -> VortexResult<()> { let args = canonical_args(Traversal::Infallible, false); let (allocator, tracker) = tracking_allocator(); - let mut ctx = array_session() + let mut ctx = VortexSession::empty() .create_execution_ctx() .with_allocator(allocator); @@ -289,7 +289,7 @@ fn sink_payloads_use_allocator(#[case] traversal: Traversal) -> VortexResult<()> let args = canonical_args(traversal, false); let valid = selected_rows(); let (allocator, tracker) = tracking_allocator(); - let mut ctx = array_session() + let mut ctx = VortexSession::empty() .create_execution_ctx() .with_allocator(allocator); @@ -341,7 +341,7 @@ fn empty_outputs_and_zero_width_rows_do_not_allocate_payloads() -> VortexResult< let empty = PrimitiveArray::from_iter(std::iter::empty::()).into_array(); let args = VecExecutionArgs::new(vec![empty], 0); let (allocator, tracker) = tracking_allocator(); - let mut ctx = array_session() + let mut ctx = VortexSession::empty() .create_execution_ctx() .with_allocator(allocator); @@ -385,7 +385,7 @@ fn empty_outputs_and_zero_width_rows_do_not_allocate_payloads() -> VortexResult< fn boolean_sinks_allocate_packed_payloads_with_context_allocator() -> VortexResult<()> { let args = canonical_args(Traversal::Infallible, false); let (allocator, tracker) = tracking_allocator(); - let mut ctx = array_session() + let mut ctx = VortexSession::empty() .create_execution_ctx() .with_allocator(allocator); @@ -485,7 +485,7 @@ fn zero_sized_output_uses_its_own_storage(#[case] traversal: Traversal) -> Vorte let valid = selected_rows(); let expected = PrimitiveArray::from_iter([1_i64; 3]).into_array(); let (allocator, tracker) = tracking_allocator(); - let mut ctx = array_session() + let mut ctx = VortexSession::empty() .create_execution_ctx() .with_allocator(allocator); diff --git a/vortex-array/src/scalar_fn/unstable/row/types/element/tuple/tests.rs b/vortex-array/src/scalar_fn/unstable/row/types/element/tuple/tests.rs index d49ca3af20c..16f639c4254 100644 --- a/vortex-array/src/scalar_fn/unstable/row/types/element/tuple/tests.rs +++ b/vortex-array/src/scalar_fn/unstable/row/types/element/tuple/tests.rs @@ -1,6 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; @@ -8,6 +9,7 @@ use vortex_buffer::Buffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_mask::Mask; +use vortex_session::VortexSession; use super::ElementTuple; use super::element_tuple::batch_const; @@ -15,7 +17,6 @@ use crate::ArrayRef; use crate::ExecutionCtx; use crate::IntoArray; use crate::VortexSessionExecute; -use crate::array_session; use crate::arrays::Constant; use crate::arrays::ConstantArray; use crate::arrays::ExtensionArray; @@ -30,6 +31,8 @@ use crate::scalar_fn::VecExecutionArgs; use crate::scalar_fn::unstable::row::InputElement; use crate::validity::Validity; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + static DECODE_CALLS: AtomicUsize = AtomicUsize::new(0); static CONSTANT_DECODE_LEN: AtomicUsize = AtomicUsize::new(0); @@ -119,7 +122,7 @@ fn test_null_tolerant_decline_precedes_decoding() -> VortexResult<()> { let first = PrimitiveArray::from_iter([1_i64, 2]).into_array(); let second = PrimitiveArray::from_iter([3_i64, 4]).into_array(); let args = VecExecutionArgs::new(vec![first, second], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let columns = <(DecodeProbe, DenseFallible)>::decode_null_tolerant(&args, &mut ctx)?; @@ -133,7 +136,7 @@ fn test_batch_constant_uses_constant_decoder() -> VortexResult<()> { DECODE_CALLS.store(0, Ordering::Relaxed); CONSTANT_DECODE_LEN.store(0, Ordering::Relaxed); let args = VecExecutionArgs::new(vec![ConstantArray::new(7_i64, 3).into_array()], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let columns = <(DecodeProbe,)>::decode(&args, &mut ctx)?; @@ -145,7 +148,7 @@ fn test_batch_constant_uses_constant_decoder() -> VortexResult<()> { #[test] fn test_batch_const_unwraps_filtered_masked_constant() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let child = ConstantArray::new(7_i64, 3).into_array(); let masked = MaskedArray::try_new(child, Validity::from_iter([true, false, true]), &mut ctx)? .into_array(); @@ -172,7 +175,7 @@ fn test_batch_const_preserves_filtered_extension() -> VortexResult<()> { }; assert_eq!(const_array.dtype(), extension.dtype()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scalar = const_array.execute_scalar(0, &mut ctx)?; assert_eq!( scalar.as_extension().to_storage_scalar(), diff --git a/vortex-array/src/scalar_fn/unstable/row/types/element/utf8.rs b/vortex-array/src/scalar_fn/unstable/row/types/element/utf8.rs index 18d9e3727d3..17b034dca94 100644 --- a/vortex-array/src/scalar_fn/unstable/row/types/element/utf8.rs +++ b/vortex-array/src/scalar_fn/unstable/row/types/element/utf8.rs @@ -318,6 +318,8 @@ unsafe impl InputElement for Utf8Column { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::ByteBuffer; @@ -353,6 +355,8 @@ mod tests { use crate::scalar_fn::unstable::row::execute_rows; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[derive(Clone)] struct StartsWithPre; @@ -390,7 +394,7 @@ mod tests { #[case::views(VarBinViewArray::from_iter_nullable_str(NULLABLE_VALUES).into_array())] fn row_fn_reads_each_storage_and_propagates_nulls(#[case] input: ArrayRef) -> VortexResult<()> { let args = VecExecutionArgs::new(vec![input.clone()], input.len()); - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let output = execute_rows(&StartsWithPre, &EmptyOptions, &args, &mut ctx)?; let expected = BoolArray::from_iter([ @@ -407,7 +411,7 @@ mod tests { #[test] fn input_reads_inline_and_referenced_views() -> VortexResult<()> { let array = VarBinViewArray::from_iter_str(["short", "a referenced string"]); - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let column = Utf8Column::decode(array.into_array(), &mut ctx)?; assert!(matches!(column.0, Utf8Storage::Views { .. })); @@ -427,7 +431,7 @@ mod tests { #[case] offsets: PrimitiveArray, #[case] shares_offsets: bool, ) -> VortexResult<()> { - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bytes = ByteBuffer::from("héllo!".as_bytes().to_vec()); let array = VarBinArray::try_new( offsets.clone().into_array(), @@ -465,7 +469,7 @@ mod tests { ) .into_array() .slice(1..3)?; - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let column = Utf8Column::decode(array, &mut ctx)?; assert!(matches!(column.0, Utf8Storage::Offsets { .. })); @@ -479,7 +483,7 @@ mod tests { /// view storage, which replaces null rows with empty strings. #[test] fn varbin_input_with_invalid_null_bytes_reads_views() -> VortexResult<()> { - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinArray::try_new( PrimitiveArray::from_iter([0u32, 1, 2]).into_array(), ByteBuffer::from(vec![b'a', 0xff]), @@ -507,7 +511,7 @@ mod tests { DType::Utf8(Nullability::Nullable), Validity::Array(validity), ); - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let column = Utf8Column::decode(array.into_array(), &mut ctx)?; assert_eq!(Utf8Column::get(&column, 0), ""); @@ -538,7 +542,7 @@ mod tests { ) .into_array() .slice(1..len + 1)?; - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for _ in 0..2 { let column = Utf8Column::decode(array.clone(), &mut ctx)?; assert_eq!(Utf8Column::view(&column).len(), len); @@ -562,7 +566,7 @@ mod tests { DType::Utf8(Nullability::NonNullable), Validity::NonNullable, ); - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!(Utf8Column::decode(array.into_array(), &mut ctx).is_err()); } @@ -572,7 +576,7 @@ mod tests { #[case("a referenced batch constant")] fn constant_decodes_inlined_and_referenced_values(#[case] value: &str) -> VortexResult<()> { let array = ConstantArray::new(Scalar::from(value), 8).into_array(); - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let constant = Utf8Column::decode_constant(array, &mut ctx)?; diff --git a/vortex-array/src/scalar_fn/unstable/row/types/sink/utf8.rs b/vortex-array/src/scalar_fn/unstable/row/types/sink/utf8.rs index 422df0fbdc2..276601ca849 100644 --- a/vortex-array/src/scalar_fn/unstable/row/types/sink/utf8.rs +++ b/vortex-array/src/scalar_fn/unstable/row/types/sink/utf8.rs @@ -161,6 +161,7 @@ unsafe impl OutputSink for Utf8Sink { #[cfg(test)] mod tests { use std::borrow::Cow; + use std::sync::LazyLock; use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexResult; @@ -173,6 +174,8 @@ mod tests { use crate::dtype::Nullability; use crate::scalar_fn::unstable::row::OutputSink; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn sink_writes_owned_borrowed_and_cow_values() -> VortexResult<()> { let expected = ["short", "a referenced string", "owned", "borrowed cow"]; @@ -200,7 +203,7 @@ mod tests { // SAFETY: every row was initialized by the writes above. let array = unsafe { ::finish(sink) }?; - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = array.execute::(&mut ctx)?; let actual = (0..array.len()) .map(|index| String::from_utf8_lossy(&array.bytes_at(index)).into_owned()) @@ -227,7 +230,7 @@ mod tests { )); // SAFETY: the skipped-row initializer initialized every row. let skipped = unsafe { ::finish(skipped) }?; - let mut ctx = VortexSession::empty().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let skipped = skipped.execute::(&mut ctx)?; assert_eq!(skipped.len(), 2); diff --git a/vortex-array/src/scalar_fn/unstable/row/vtable.rs b/vortex-array/src/scalar_fn/unstable/row/vtable.rs index 41950737f49..32212d367e0 100644 --- a/vortex-array/src/scalar_fn/unstable/row/vtable.rs +++ b/vortex-array/src/scalar_fn/unstable/row/vtable.rs @@ -231,19 +231,20 @@ fn prepare_batch( #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; use rstest::rstest; use vortex_error::VortexError; use vortex_error::VortexResult; + use vortex_session::VortexSession; use vortex_session::registry::CachedId; use super::execute_rows; use super::row_fn_return_dtype; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; use crate::dtype::DType; @@ -254,6 +255,8 @@ mod tests { use crate::scalar_fn::unstable::row::RowVisitor; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[derive(Clone)] struct IndexingRowFn; @@ -357,7 +360,7 @@ mod tests { #[test] fn test_execute_rejects_wrong_arity_before_dispatch() { let args = VecExecutionArgs::new(vec![], 0); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = execute_rows(&IndexingRowFn, &EmptyOptions, &args, &mut ctx) .expect_err("wrong arity must fail before dispatch"); @@ -369,7 +372,7 @@ mod tests { #[case::nonempty(3)] fn test_execute_nullary_rows(#[case] row_count: usize) -> VortexResult<()> { let args = VecExecutionArgs::new(vec![], row_count); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = execute_rows(&NullarySeven, &EmptyOptions, &args, &mut ctx)?; let expected = PrimitiveArray::from_iter(vec![7_i64; row_count]).into_array(); @@ -386,7 +389,7 @@ mod tests { }; let input = PrimitiveArray::new(vec![1_i64, 2], Validity::NonNullable).into_array(); let args = VecExecutionArgs::new(vec![input], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = match execute_rows(&function, &EmptyOptions, &args, &mut ctx) { Err(error) => error, @@ -413,7 +416,7 @@ mod tests { }; let input = PrimitiveArray::new(vec![1_i64, 2], Validity::NonNullable).into_array(); let args = VecExecutionArgs::new(vec![input], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = match execute_rows(&function, &EmptyOptions, &args, &mut ctx) { Err(error) => error, diff --git a/vortex-array/src/search_sorted/primitive.rs b/vortex-array/src/search_sorted/primitive.rs index dada11afb62..69601ac71f8 100644 --- a/vortex-array/src/search_sorted/primitive.rs +++ b/vortex-array/src/search_sorted/primitive.rs @@ -141,12 +141,14 @@ impl IndexOrd for SearchSortedPrimitiveArray<'_, T> { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::Reader; use crate::IntoArray; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::executor::VortexSessionExecute; use crate::search_sorted::SearchResult; @@ -155,9 +157,11 @@ mod tests { use crate::search_sorted::SearchSortedSide; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn search_sorted_reads_canonical_values_directly() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new(buffer![1i32, 2, 3, 4], Validity::NonNullable).into_array(); let searcher = SearchSortedPrimitiveArray::::new(&array, &mut ctx); assert!(matches!(searcher.reader, Reader::Values(_))); @@ -170,7 +174,7 @@ mod tests { #[test] fn search_sorted_nullable_values_respects_validity() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new( buffer![99i32, 2, 3, 4], Validity::from_iter([false, true, true, true]), @@ -191,7 +195,7 @@ mod tests { #[test] fn search_sorted_optional_value() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![1i32, 2, 3, 4], Validity::AllValid).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let res = SearchSortedPrimitiveArray::::new(&array, &mut ctx) .search_sorted(&Some(3i32), SearchSortedSide::Left)?; assert_eq!(res, SearchResult::Found(2)); @@ -202,7 +206,7 @@ mod tests { fn search_sorted_optional_value_with_nulls() -> VortexResult<()> { let array = PrimitiveArray::from_option_iter([None, None, Some(2i32), Some(3)]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let searcher = SearchSortedPrimitiveArray::::new(&array, &mut ctx); assert_eq!( searcher.search_sorted(&Some(2i32), SearchSortedSide::Left)?, diff --git a/vortex-array/src/search_sorted/scalar.rs b/vortex-array/src/search_sorted/scalar.rs index 907bcba16e5..675e2618772 100644 --- a/vortex-array/src/search_sorted/scalar.rs +++ b/vortex-array/src/search_sorted/scalar.rs @@ -55,11 +55,13 @@ impl IndexOrd for SearchSortedArray<'_> { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::IntoArray; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::executor::VortexSessionExecute; use crate::scalar::Scalar; @@ -69,11 +71,13 @@ mod tests { use crate::search_sorted::SearchSortedSide; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn search_sorted_scalar() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![1i32, 2, 3, 3, 4], Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let searcher = SearchSortedArray::new(&array, &mut ctx); assert_eq!( searcher.search_sorted(&Scalar::from(3i32), SearchSortedSide::Left)?, @@ -94,7 +98,7 @@ mod tests { fn search_sorted_scalar_with_nulls() -> VortexResult<()> { let array = PrimitiveArray::from_option_iter([None, None, Some(2i32), Some(3)]).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let searcher = SearchSortedArray::new(&array, &mut ctx); assert_eq!( searcher.search_sorted(&Scalar::from(Some(2i32)), SearchSortedSide::Left)?, diff --git a/vortex-array/src/serde.rs b/vortex-array/src/serde.rs index 5a07d6daa28..e87d8bc7e77 100644 --- a/vortex-array/src/serde.rs +++ b/vortex-array/src/serde.rs @@ -769,12 +769,14 @@ impl TryFrom for SerializedArray { #[cfg(test)] mod tests { + use std::sync::LazyLock; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; use vortex_buffer::ByteBufferMut; use vortex_error::vortex_ensure; use vortex_error::vortex_ensure_eq; + use vortex_session::VortexSession; use vortex_session::registry::CachedId; use super::*; @@ -784,11 +786,12 @@ mod tests { use crate::ArrayVTable; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Primitive; use crate::arrays::PrimitiveArray; use crate::assert_arrays_eq; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + static SERIALIZER_CALLS: AtomicUsize = AtomicUsize::new(0); fn old_primitive_id() -> ArrayId { @@ -896,7 +899,7 @@ mod tests { } fn versioned_primitive_session() -> VortexSession { - let session = array_session(); + let session = VortexSession::empty(); session.arrays().register(VersionedPrimitivePlugin); session } @@ -919,7 +922,7 @@ mod tests { #[test] fn serialization_preserves_plugin_selected_old_wire_id() -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); session.arrays().register(CountingVersionedPrimitivePlugin); let ctx = restricted_context(&[old_primitive_id(), new_primitive_id()]); let array = PrimitiveArray::from_iter([1i32, 2, 3, 4]).into_array(); @@ -988,9 +991,8 @@ mod tests { let serialized = SerializedArray::try_from(serialize_blob(&array, &ctx, &writer_session)?)?; let read_ctx = ReadContext::new(ctx.to_ids()); - let old_session = array_session(); let error = serialized - .decode(array.dtype(), array.len(), &read_ctx, &old_session) + .decode(array.dtype(), array.len(), &read_ctx, &SESSION) .expect_err("an old reader must not recognize the new wire ID"); assert!(error.to_string().contains("Unknown encoding")); Ok(()) @@ -1021,14 +1023,13 @@ mod tests { /// such a buffer must return a [`VortexError`] rather than panicking (see issue #8819). #[test] fn from_flatbuffer_and_segment_rejects_out_of_bounds_buffer() -> VortexResult<()> { - let session = array_session(); let array_ctx = ArrayContext::empty(); // Serialize a simple array so we have a valid array tree flatbuffer whose declared buffer // lengths describe the trailing data segment. let serialized = PrimitiveArray::from_iter([1i32, 2, 3, 4]) .into_array() - .serialize(&array_ctx, &session, &SerializeOptions::default())?; + .serialize(&array_ctx, &SESSION, &SerializeOptions::default())?; let mut concat = ByteBufferMut::empty(); for buf in serialized { diff --git a/vortex-array/src/stats/expr.rs b/vortex-array/src/stats/expr.rs index e31d026d6e8..a9abc70c0b7 100644 --- a/vortex-array/src/stats/expr.rs +++ b/vortex-array/src/stats/expr.rs @@ -185,7 +185,6 @@ mod tests { use crate::Canonical; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::Chunked; use crate::arrays::ChunkedArray; use crate::arrays::ConstantArray; @@ -203,7 +202,7 @@ mod tests { use crate::scalar::ScalarValue; use crate::validity::Validity; - static SESSION: LazyLock = LazyLock::new(array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn bound_stats_constructor_preserves_child_and_dtype() -> VortexResult<()> { diff --git a/vortex-array/src/stats/flatbuffers.rs b/vortex-array/src/stats/flatbuffers.rs index ee9d7d45e78..2e385885e5a 100644 --- a/vortex-array/src/stats/flatbuffers.rs +++ b/vortex-array/src/stats/flatbuffers.rs @@ -237,8 +237,8 @@ mod tests { use flatbuffers::root; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; - use crate::array_session; use crate::dtype::DType; use crate::dtype::Nullability; use crate::dtype::PType; @@ -266,7 +266,7 @@ mod tests { assert_eq!(fb.sum().expect("serialized sum").bytes(), expected_bytes); let dtype = DType::Primitive(PType::F64, Nullability::NonNullable); - let read = StatsSet::from_flatbuffer(&fb, &dtype, &array_session())?; + let read = StatsSet::from_flatbuffer(&fb, &dtype, &VortexSession::empty())?; Ok(read .get_as::( Stat::Sum, diff --git a/vortex-array/src/stats/rewrite.rs b/vortex-array/src/stats/rewrite.rs index 24ba509a364..ffc521473e0 100644 --- a/vortex-array/src/stats/rewrite.rs +++ b/vortex-array/src/stats/rewrite.rs @@ -143,6 +143,8 @@ fn rewrite( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_error::VortexResult; use vortex_session::VortexSession; @@ -159,6 +161,8 @@ mod tests { use crate::scalar_fn::fns::not::Not; use crate::stats::session::StatsSessionExt; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[derive(Debug)] struct StaticNotRule { falsifier: Option, @@ -189,7 +193,7 @@ mod tests { #[test] fn combines_multiple_falsifiers_with_or() -> VortexResult<()> { - let session = crate::array_session(); + let session = VortexSession::empty(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); session.stats().register_rewrite(StaticNotRule { falsifier: Some(lit(false).bind(&dtype)?), @@ -209,7 +213,7 @@ mod tests { #[test] fn combines_multiple_satisfiers_with_or() -> VortexResult<()> { - let session = crate::array_session(); + let session = VortexSession::empty(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); session.stats().register_rewrite(StaticNotRule { falsifier: None, @@ -229,23 +233,21 @@ mod tests { #[test] fn unregistered_expression_has_no_rewrite() -> VortexResult<()> { - let session = crate::array_session(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let expr = not(lit(true)).bind(&dtype)?; - assert_eq!(expr.falsify(&session)?, None); - assert_eq!(expr.satisfy(&session)?, None); + assert_eq!(expr.falsify(&SESSION)?, None); + assert_eq!(expr.satisfy(&SESSION)?, None); Ok(()) } #[test] fn non_predicate_expression_errors() -> VortexResult<()> { - let session = crate::array_session(); let dtype = DType::Primitive(PType::I32, Nullability::NonNullable); let expr = lit(7).bind(&dtype)?; - assert!(expr.falsify(&session).is_err()); - assert!(expr.satisfy(&session).is_err()); + assert!(expr.falsify(&SESSION).is_err()); + assert!(expr.satisfy(&SESSION).is_err()); Ok(()) } } diff --git a/vortex-array/src/stats/rewrite/builtins.rs b/vortex-array/src/stats/rewrite/builtins.rs index 759274bd5fe..d1ef7e00b2c 100644 --- a/vortex-array/src/stats/rewrite/builtins.rs +++ b/vortex-array/src/stats/rewrite/builtins.rs @@ -854,7 +854,6 @@ mod tests { use crate::aggregate_fn::AggregateFnVTableExt; use crate::aggregate_fn::EmptyOptions as AggregateEmptyOptions; use crate::aggregate_fn::fns::all_non_nan::AllNonNan; - use crate::array_session; use crate::dtype::DType; use crate::dtype::Nullability; use crate::dtype::PType; @@ -897,7 +896,7 @@ mod tests { use crate::stats::rewrite::StatsRewriteRule; use crate::stats::session::StatsSessionExt; - static SESSION: LazyLock = LazyLock::new(array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); fn stat(expr: Expression, stat: Stat) -> Expression { let aggregate_fn = stat.aggregate_fn().expect("stat should have aggregate fn"); @@ -1047,7 +1046,7 @@ mod tests { #[test] fn or_chain_falsify_visits_each_node_once() -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); let visits = Arc::new(AtomicUsize::new(0)); session .stats() diff --git a/vortex-array/src/stats/stats_set.rs b/vortex-array/src/stats/stats_set.rs index 11429a4d1ca..eb898bd387c 100644 --- a/vortex-array/src/stats/stats_set.rs +++ b/vortex-array/src/stats/stats_set.rs @@ -597,13 +597,15 @@ impl MutTypedStatsSetRef<'_, '_> { #[cfg(test)] mod test { + use std::sync::LazyLock; + use enum_iterator::all; use itertools::Itertools; use rstest::rstest; use smallvec::smallvec; + use vortex_session::VortexSession; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::DType; use crate::dtype::DecimalDType; @@ -622,6 +624,8 @@ mod test { use crate::stats::StatsSet; use crate::stats::stats_set::Scalar; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_iter() { // SAFETY: No duplicate stats. @@ -1004,7 +1008,7 @@ mod test { .collect_vec(); array .statistics() - .compute_all(&all_stats, &mut array_session().create_execution_ctx()) + .compute_all(&all_stats, &mut SESSION.create_execution_ctx()) .unwrap(); let stats = array.statistics().to_owned(); diff --git a/vortex-array/src/validity.rs b/vortex-array/src/validity.rs index d1acdf650df..449f66b07d9 100644 --- a/vortex-array/src/validity.rs +++ b/vortex-array/src/validity.rs @@ -631,20 +631,24 @@ impl IntoArray for &MaskValues { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::ArrayRef; use crate::IntoArray; use crate::VortexSessionExecute; - use crate::array_session; use crate::arrays::PrimitiveArray; use crate::dtype::Nullability; use crate::validity::BoolArray; use crate::validity::Validity; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(Validity::AllValid, 5, &[2, 4], Validity::AllValid, Validity::AllValid)] #[case( @@ -708,7 +712,7 @@ mod tests { let indices = PrimitiveArray::new(Buffer::copy_from(positions), Validity::NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert!( validity @@ -735,7 +739,7 @@ mod tests { #[case] index: u64, #[case] message: &str, ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = validity .patch( 2, @@ -788,7 +792,7 @@ mod tests { #[case] indices: ArrayRef, #[case] expected: Validity, ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let taken = validity.take(&indices).unwrap(); assert_eq!(taken.nullability(), expected.nullability()); assert!(taken.mask_eq(&expected, indices.len(), &mut ctx).unwrap()); @@ -831,7 +835,7 @@ mod tests { #[case] rhs: Validity, #[case] expected: bool, ) -> vortex_error::VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!(lhs.mask_eq(&rhs, 3, &mut ctx)?, expected); Ok(()) } diff --git a/vortex-arrow/benches/to_arrow.rs b/vortex-arrow/benches/to_arrow.rs index 9833bcc64d0..bc063d0dfe5 100644 --- a/vortex-arrow/benches/to_arrow.rs +++ b/vortex-arrow/benches/to_arrow.rs @@ -18,7 +18,7 @@ use vortex_array::ArrayRef; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::DictArray; @@ -33,7 +33,13 @@ use vortex_array::dtype::DecimalDType; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; use vortex_array::dtype::StructFields; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; use vortex_array::session::ArraySessionExt; +use vortex_array::stats::session::StatsSession; #[expect( deprecated, reason = "benchmark comparing deprecated method with new one" @@ -56,7 +62,14 @@ fn main() { } static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session(); + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::(); vortex_fsst::initialize(&session); vortex_onpair::initialize(&session); session.arrays().register(Zstd); diff --git a/vortex-arrow/src/convert.rs b/vortex-arrow/src/convert.rs index bc25b1a9406..a2760a82883 100644 --- a/vortex-arrow/src/convert.rs +++ b/vortex-arrow/src/convert.rs @@ -746,6 +746,7 @@ pub fn from_arrow_batch(batch: &RecordBatch, nullable: bool) -> VortexResult = LazyLock::new(VortexSession::empty); + #[rstest] #[case::i8( Arc::new(Int8Array::from(vec![Some(1), None, Some(3), Some(4)])), @@ -950,12 +953,12 @@ mod tests { assert_arrays_eq!( v_null, expected_nullable, - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( v_non_null, expected_non_nullable, - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -993,7 +996,7 @@ mod tests { None, Some(::Native::from_f32(3.5)) ]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_array_non_null, @@ -1001,7 +1004,7 @@ mod tests { ::Native::from_f32(1.5), ::Native::from_f32(2.5) ]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1047,12 +1050,12 @@ mod tests { [Some(12345i128), None, Some(67890i128), Some(11111i128)], DecimalDType::new(10, 2) ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_array_non_null, DecimalArray::from_iter([12345i128, 67890i128, 11111i128], DecimalDType::new(10, 2)), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1102,7 +1105,7 @@ mod tests { ], DecimalDType::new(38, 10) ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_array_non_null, @@ -1114,7 +1117,7 @@ mod tests { ], DecimalDType::new(38, 10) ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1243,15 +1246,11 @@ mod tests { _ => unreachable!(), } }; - assert_arrays_eq!( - v_null, - expected(true), - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(v_null, expected(true), &mut SESSION.create_execution_ctx()); assert_arrays_eq!( v_non_null, expected(false), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1298,7 +1297,7 @@ mod tests { TimeUnit::Microseconds, Some("UTC".into()) ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_array_non_null, @@ -1307,7 +1306,7 @@ mod tests { TimeUnit::Microseconds, Some("UTC".into()) ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1358,7 +1357,7 @@ mod tests { [Some("hello"), None, Some("world"), Some("test")], expected_non_nullable_dtype.as_nullable() ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( v_non_null, @@ -1366,7 +1365,7 @@ mod tests { ["hello", "world", "test", "vortex"], expected_non_nullable_dtype ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1414,7 +1413,7 @@ mod tests { [Some("hello"), None, Some("world"), Some("test")], DType::Utf8(Nullability::NonNullable).as_nullable() ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_array_non_null, @@ -1422,7 +1421,7 @@ mod tests { ["hello", "world", "test", "vortex"], DType::Utf8(Nullability::NonNullable) ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1470,7 +1469,7 @@ mod tests { [Some("hello"), None, Some("world"), Some("test")], DType::Binary(Nullability::NonNullable).as_nullable() ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_array_non_null, @@ -1478,7 +1477,7 @@ mod tests { ["hello", "world", "test", "vortex"], DType::Binary(Nullability::NonNullable) ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1496,12 +1495,12 @@ mod tests { assert_arrays_eq!( vortex_array, BoolArray::from_iter([Some(true), None, Some(false), Some(true)]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_array_non_null, BoolArray::from_iter([true, false, true, false]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1570,19 +1569,19 @@ mod tests { assert_arrays_eq!( vortex_array, expected(Validity::NonNullable), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_nullable_array, expected(Validity::from_iter([true, false, true])), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } // Test list array conversions #[test] fn test_list_array_conversion() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = ListBuilder::new(Int32Builder::new()); builder.append_value([Some(1), None, Some(3)]); builder.append_null(); @@ -1622,11 +1621,7 @@ mod tests { Validity::from_iter([true, false, true]), &mut ctx, ); - assert_arrays_eq!( - vortex_array, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(vortex_array, expected, &mut SESSION.create_execution_ctx()); let expected = ListArray::new( expected_elements, buffer![0u32, 3, 5].into_array(), @@ -1636,7 +1631,7 @@ mod tests { assert_arrays_eq!( vortex_array_non_null, expected, - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1652,7 +1647,7 @@ mod tests { } builder.finish() }; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // A slice keeps its parent's whole child; the import must not. let sliced = from_arrow_dyn(&strings(0..1000).slice(500, 2), false)?; @@ -1682,7 +1677,7 @@ mod tests { #[test] fn test_large_list_array_conversion() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = LargeListBuilder::new(Int32Builder::new()); builder.append_value([Some(1), None, Some(3)]); builder.append_null(); @@ -1722,11 +1717,7 @@ mod tests { Validity::from_iter([true, false, true]), &mut ctx, ); - assert_arrays_eq!( - vortex_array, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(vortex_array, expected, &mut SESSION.create_execution_ctx()); let expected = ListArray::new( expected_elements, buffer![0u32, 3, 5].into_array(), @@ -1736,7 +1727,7 @@ mod tests { assert_arrays_eq!( vortex_array_non_null, expected, - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1826,7 +1817,7 @@ mod tests { Validity::NonNullable, 4 ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_array_nullable, @@ -1847,13 +1838,13 @@ mod tests { Validity::from_iter([true, false, true]), 3 ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } #[test] fn test_list_view_array_conversion() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create values array for the lists let values = Int32Array::from(vec![ Some(1), @@ -1948,17 +1939,17 @@ mod tests { assert_arrays_eq!( vortex_array, expected(Validity::NonNullable), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( vortex_array_nullable, expected(Validity::from_iter([true, false, true, true])), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); assert_arrays_eq!( large_vortex_array, expected(Validity::NonNullable), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1971,7 +1962,7 @@ mod tests { assert_arrays_eq!( vortex_array, VortexNullArray::new(5), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1985,7 +1976,7 @@ mod tests { assert_arrays_eq!( vortex_array, buffer![1u8, 2, 3, 4, 5].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -1998,7 +1989,7 @@ mod tests { assert_arrays_eq!( vortex_array, BoolArray::from_iter([true, false, true, false, true]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -2011,7 +2002,7 @@ mod tests { assert_arrays_eq!( vortex_array, buffer![1i32, 2, 3, 4, 5].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -2024,7 +2015,7 @@ mod tests { assert_arrays_eq!( vortex_array, buffer![0i32, 2, 5, 8, 10].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -2055,11 +2046,7 @@ mod tests { 4, Validity::NonNullable, ); - assert_arrays_eq!( - vortex_array, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(vortex_array, expected, &mut SESSION.create_execution_ctx()); // Test with reference let schema = Arc::new(Schema::new(vec![ @@ -2086,11 +2073,7 @@ mod tests { 4, Validity::NonNullable, ); - assert_arrays_eq!( - vortex_array, - expected, - &mut array_session().create_execution_ctx() - ); + assert_arrays_eq!(vortex_array, expected, &mut SESSION.create_execution_ctx()); } // Test dynamic dispatch conversion @@ -2102,7 +2085,7 @@ mod tests { assert_arrays_eq!( vortex_array, buffer![1i32, 2, 3, 4].into_array(), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); let string_array = StringArray::from(vec!["a", "b", "c"]); @@ -2111,7 +2094,7 @@ mod tests { assert_arrays_eq!( vortex_array, VarBinArray::from_iter_nonnull(["a", "b", "c"], DType::Utf8(Nullability::NonNullable)), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); let bool_array = BooleanArray::from(vec![true, false, true]); @@ -2120,7 +2103,7 @@ mod tests { assert_arrays_eq!( vortex_array, BoolArray::from_iter([true, false, true]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -2145,7 +2128,7 @@ mod tests { 1, Validity::AllInvalid ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -2181,7 +2164,7 @@ mod tests { 1, Validity::AllInvalid ), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); } @@ -2224,7 +2207,7 @@ mod tests { Scalar::primitive(1i32, Nullability::Nullable), )], )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for actual in [&direct, imported.as_::().unmasked_field(0)] { assert_eq!(actual.len(), 2); assert_eq!(actual.execute_scalar(0, &mut ctx)?, row); diff --git a/vortex-arrow/src/executor/byte.rs b/vortex-arrow/src/executor/byte.rs index eadb581751d..c593bd24074 100644 --- a/vortex-arrow/src/executor/byte.rs +++ b/vortex-arrow/src/executor/byte.rs @@ -192,6 +192,8 @@ fn utf8_from_bytes(bytes: &[u8]) -> Result<&str, simdutf8::compat::Utf8Error> { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use arrow_array::Array; use arrow_array::cast::AsArray; use arrow_schema::DataType; @@ -199,7 +201,6 @@ mod tests { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinArray; @@ -212,13 +213,15 @@ mod tests { use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::ArrowSessionExt; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn mask_wrapped_varbin_exports() -> VortexResult<()> { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let varbin = VarBinArray::from_vec( vec!["hello", "world", "vortex"], @@ -228,7 +231,7 @@ mod tests { let masked = MaskFn::try_new(varbin.into_array(), mask.into_array())?.into_array(); let field = Field::new("s", DataType::Utf8, true); - let arrow = session + let arrow = SESSION .arrow() .execute_arrow(masked, Some(&field), &mut ctx)?; @@ -275,10 +278,9 @@ mod tests { #[case] vortex_array: VarBinViewArray, #[case] target_dtype: DataType, ) { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let field = Field::new("test_field", target_dtype.clone(), true); - let arrow = session + let arrow = SESSION .arrow() .execute_arrow(vortex_array.into_array(), Some(&field), &mut ctx) .unwrap(); @@ -324,10 +326,9 @@ mod tests { vortex_dtype, ); - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let field = Field::new("test_field", target_dtype.clone(), true); - let arrow = session + let arrow = SESSION .arrow() .execute_arrow(vortex_array.into_array(), Some(&field), &mut ctx) .unwrap(); @@ -361,11 +362,10 @@ mod tests { b"\xff\xfe invalid utf8".as_slice(), ]); - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let field = Field::new("test_field", target_dtype, true); let result = - session + SESSION .arrow() .execute_arrow(vortex_array.into_array(), Some(&field), &mut ctx); @@ -379,8 +379,7 @@ mod tests { #[case(DataType::Utf8)] #[case(DataType::LargeUtf8)] fn binary_to_string_rejects_offsets_splitting_a_character(#[case] target_dtype: DataType) { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinArray::new( buffer![0i32, 1, 2].into_array(), ByteBuffer::copy_from("é".as_bytes()), @@ -389,7 +388,7 @@ mod tests { &mut ctx, ); let field = Field::new("test_field", target_dtype, false); - let result = session + let result = SESSION .arrow() .execute_arrow(array.into_array(), Some(&field), &mut ctx); @@ -403,8 +402,7 @@ mod tests { fn binary_to_string_accepts_multibyte_characters( #[case] target_dtype: DataType, ) -> VortexResult<()> { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinArray::new( buffer![0i32, 2, 5].into_array(), ByteBuffer::copy_from("é☃".as_bytes()), @@ -413,7 +411,7 @@ mod tests { &mut ctx, ); let field = Field::new("test_field", target_dtype.clone(), false); - let arrow = session + let arrow = SESSION .arrow() .execute_arrow(array.into_array(), Some(&field), &mut ctx)?; @@ -436,8 +434,7 @@ mod tests { #[case] target_dtype: DataType, ) -> VortexResult<()> { // Slot 1 is null and its offsets still span two bytes that are not valid UTF-8. - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinArray::new( buffer![0i32, 5, 7, 12].into_array(), ByteBuffer::copy_from(b"hello\xff\xfeworld".as_slice()), @@ -446,7 +443,7 @@ mod tests { &mut ctx, ); let field = Field::new("test_field", target_dtype, true); - let arrow = session + let arrow = SESSION .arrow() .execute_arrow(array.into_array(), Some(&field), &mut ctx)?; @@ -466,10 +463,9 @@ mod tests { #[case(DataType::Binary)] #[case(DataType::LargeBinary)] fn incompatible_vortex_dtype_returns_error(#[case] target_dtype: DataType) { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let field = Field::new("test_field", target_dtype, true); - let result = session.arrow().execute_arrow( + let result = SESSION.arrow().execute_arrow( PrimitiveArray::from_iter([1i32, 2, 3]).into_array(), Some(&field), &mut ctx, @@ -487,9 +483,8 @@ mod tests { .into_array() .filter(Mask::from_iter([true, false, false]))?; - let session = array_session(); - let mut ctx = session.create_execution_ctx(); - let arrow = session + let mut ctx = SESSION.create_execution_ctx(); + let arrow = SESSION .arrow() .execute_arrow(filtered.into_array(), None, &mut ctx)?; diff --git a/vortex-arrow/src/executor/byte_view.rs b/vortex-arrow/src/executor/byte_view.rs index 48aae3c6d2c..e99980867fc 100644 --- a/vortex-arrow/src/executor/byte_view.rs +++ b/vortex-arrow/src/executor/byte_view.rs @@ -74,16 +74,20 @@ pub(super) fn to_arrow_byte_view( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use arrow_array::types::StringViewType; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; + use vortex_session::VortexSession; use super::*; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn empty_views_are_aligned() -> VortexResult<()> { let array = VarBinViewArray::from_iter_str(std::iter::empty::<&str>()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let arrow = canonical_varbinview_to_arrow::(&array, &mut ctx)?; diff --git a/vortex-arrow/src/executor/decimal.rs b/vortex-arrow/src/executor/decimal.rs index 819a89d0e22..d86406277bd 100644 --- a/vortex-arrow/src/executor/decimal.rs +++ b/vortex-arrow/src/executor/decimal.rs @@ -222,6 +222,8 @@ fn to_arrow_decimal256(array: DecimalArray, ctx: &mut ExecutionCtx) -> VortexRes #[cfg(test)] mod tests { + use std::sync::LazyLock; + use arrow_array::Array; use arrow_array::Decimal128Array; use arrow_array::Decimal256Array; @@ -230,7 +232,6 @@ mod tests { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::builders::ArrayBuilder; use vortex_array::builders::DecimalBuilder; use vortex_array::dtype::DecimalDType; @@ -238,13 +239,16 @@ mod tests { use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrowArrayExecutor; use crate::executor::decimal::DecimalArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn decimal_to_arrow() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Make a very simple i128 and i256 array. let decimal_vortex = DecimalArray::new( buffer![1i128, 2i128, 3i128, 4i128, 5i128], @@ -277,7 +281,7 @@ mod tests { fn test_to_arrow_decimal128( #[case] _decimal_type: T, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut decimal = DecimalBuilder::new_in::( DecimalDType::new(2, 1), false.into(), @@ -313,7 +317,7 @@ mod tests { fn test_to_arrow_decimal32(#[case] _decimal_type: T) -> VortexResult<()> { use arrow_array::Decimal32Array; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut decimal = DecimalBuilder::new_in::( DecimalDType::new(2, 1), false.into(), @@ -349,7 +353,7 @@ mod tests { fn test_to_arrow_decimal64(#[case] _decimal_type: T) -> VortexResult<()> { use arrow_array::Decimal64Array; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut decimal = DecimalBuilder::new_in::( DecimalDType::new(2, 1), false.into(), @@ -385,7 +389,7 @@ mod tests { fn test_to_arrow_decimal256( #[case] _decimal_type: T, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut decimal = DecimalBuilder::new_in::( DecimalDType::new(2, 1), false.into(), diff --git a/vortex-arrow/src/executor/dictionary.rs b/vortex-arrow/src/executor/dictionary.rs index 8f16ec28528..343c08357af 100644 --- a/vortex-arrow/src/executor/dictionary.rs +++ b/vortex-arrow/src/executor/dictionary.rs @@ -157,6 +157,7 @@ fn make_dict_array( #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use arrow_array::DictionaryArray as ArrowDictArray; use arrow_array::StringArray; @@ -166,7 +167,6 @@ mod tests { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinViewArray; @@ -176,11 +176,14 @@ mod tests { use vortex_array::scalar_fn::fns::mask::Mask; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrowArrayExecutor; use crate::executor::dictionary::ConstantArray; use crate::executor::dictionary::DictArray; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn dict_type(codes: DataType, values: DataType) -> DataType { DataType::Dictionary(Box::new(codes), Box::new(values)) } @@ -189,7 +192,7 @@ mod tests { array: vortex_array::ArrayRef, dt: &DataType, ) -> VortexResult { - array.execute_arrow(Some(dt), &mut array_session().create_execution_ctx()) + array.execute_arrow(Some(dt), &mut SESSION.create_execution_ctx()) } fn dict_basic_input() -> vortex_array::ArrayRef { diff --git a/vortex-arrow/src/executor/list.rs b/vortex-arrow/src/executor/list.rs index 7239b2bc030..8246f36155f 100644 --- a/vortex-arrow/src/executor/list.rs +++ b/vortex-arrow/src/executor/list.rs @@ -247,7 +247,7 @@ mod tests { use crate::executor::list::ListViewArray; /// A shared session for these list-executor tests, used to create execution contexts. - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_to_arrow_list_i32() -> VortexResult<()> { diff --git a/vortex-arrow/src/executor/list_view.rs b/vortex-arrow/src/executor/list_view.rs index 633655dcc99..2bae37f5835 100644 --- a/vortex-arrow/src/executor/list_view.rs +++ b/vortex-arrow/src/executor/list_view.rs @@ -147,7 +147,7 @@ mod tests { use crate::executor::list_view::PrimitiveArray; /// A shared session for these list-view-executor tests, used to create execution contexts. - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn trims_zero_copy_with_significant_trailing_waste() -> VortexResult<()> { diff --git a/vortex-arrow/src/executor/map.rs b/vortex-arrow/src/executor/map.rs index f93b5a34179..fb6c9239b55 100644 --- a/vortex-arrow/src/executor/map.rs +++ b/vortex-arrow/src/executor/map.rs @@ -69,6 +69,7 @@ pub(super) fn to_arrow_map( #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use arrow_array::Array as ArrowArray; use arrow_array::ArrayRef as ArrowArrayRef; @@ -88,7 +89,6 @@ mod tests { use arrow_schema::Fields; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::ListView; use vortex_array::arrays::Map as VortexMap; use vortex_array::arrays::listview::ListViewArrayExt; @@ -103,10 +103,13 @@ mod tests { use vortex_array::scalar::Scalar; use vortex_error::VortexResult; use vortex_mask::Mask; + use vortex_session::VortexSession; use crate::convert::from_arrow_map; use crate::session::ArrowSessionExt as _; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn i32_utf8_map_field(keys_sorted: bool, nullable: bool) -> Field { let fields = Fields::from(vec![ Field::new("key", DataType::Int32, false), @@ -153,7 +156,7 @@ mod tests { #[test] fn map_roundtrip_preserves_null_empty_duplicate_and_sorted_rows() -> VortexResult<()> { - let vortex_session = array_session(); + let vortex_session = VortexSession::empty(); let mut ctx = vortex_session.create_execution_ctx(); let session = vortex_session.arrow(); let field = i32_utf8_map_field(true, true); @@ -222,7 +225,7 @@ mod tests { )? ); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for (row, key, value) in [(0, 1i32, "one"), (1, 2, "two")] { let scalar = vortex.execute_scalar(row, &mut ctx)?; assert_eq!( @@ -239,7 +242,7 @@ mod tests { #[test] fn arrow_rs_map_builder_default_field_names_import() -> VortexResult<()> { - let vortex_session = array_session(); + let vortex_session = VortexSession::empty(); let mut ctx = vortex_session.create_execution_ctx(); let session = vortex_session.arrow(); let mut builder = ArrowMapBuilder::new(None, StringBuilder::new(), Int32Builder::new()); @@ -322,7 +325,7 @@ mod tests { #[test] fn arrow_map_import_sets_zero_copy_to_list() -> VortexResult<()> { - let vortex_session = array_session(); + let vortex_session = VortexSession::empty(); let session = vortex_session.arrow(); let field = i32_utf8_map_field(false, false); let arrow = i32_utf8_map_array( @@ -359,7 +362,7 @@ mod tests { #[test] fn sliced_arrow_map_import_preserves_nonzero_offsets() -> VortexResult<()> { - let vortex_session = array_session(); + let vortex_session = VortexSession::empty(); let mut ctx = vortex_session.create_execution_ctx(); let session = vortex_session.arrow(); let field = i32_utf8_map_field(true, false); @@ -406,7 +409,7 @@ mod tests { #[test] fn filtered_map_with_entry_gap_exports_correct_rows() -> VortexResult<()> { - let vortex_session = array_session(); + let vortex_session = VortexSession::empty(); let mut ctx = vortex_session.create_execution_ctx(); let session = vortex_session.arrow(); let map_dtype = MapDType::try_new( @@ -473,7 +476,7 @@ mod tests { #[test] fn unsorted_map_rejects_sorted_arrow_target() -> VortexResult<()> { - let vortex_session = array_session(); + let vortex_session = VortexSession::empty(); let mut ctx = vortex_session.create_execution_ctx(); let session = vortex_session.arrow(); let source_field = i32_utf8_map_field(false, false); @@ -497,7 +500,7 @@ mod tests { #[test] fn malformed_map_field_errors_without_panic() -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); let arrow_session = session.arrow(); let arrow = i32_utf8_map_array(vec![0, 1], vec![1], vec![Some("one")], None, false)?; let fields = Fields::from(vec![ diff --git a/vortex-arrow/src/executor/mod.rs b/vortex-arrow/src/executor/mod.rs index ab7c562bf7c..bc2256584fc 100644 --- a/vortex-arrow/src/executor/mod.rs +++ b/vortex-arrow/src/executor/mod.rs @@ -292,6 +292,7 @@ pub(crate) fn infer_nearest_arrow_field( #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use arrow_array::Array; use arrow_array::ArrayRef as ArrowArrayRef; @@ -309,13 +310,15 @@ mod tests { use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::VarBinViewArray; + use vortex_session::VortexSession; use crate::ArrowSessionExt; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn utf8() -> ArrayRef { VarBinViewArray::from_iter_str(["a", "bb"]).into_array() } @@ -353,11 +356,10 @@ mod tests { #[case::byte_from_primitive(primitive(), DataType::Utf8)] #[case::byte_from_bool(boolean(), DataType::Binary)] fn incompatible_target_returns_error(#[case] array: ArrayRef, #[case] target: DataType) { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let field = Field::new("f", target.clone(), array.dtype().is_nullable()); - let result = session.arrow().execute_arrow(array, Some(&field), &mut ctx); + let result = SESSION.arrow().execute_arrow(array, Some(&field), &mut ctx); assert!( result.is_err(), @@ -379,11 +381,10 @@ mod tests { #[case] target: DataType, #[case] expected: ArrowArrayRef, ) { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let field = Field::new("f", target, array.dtype().is_nullable()); - let result = session.arrow().execute_arrow(array, Some(&field), &mut ctx); + let result = SESSION.arrow().execute_arrow(array, Some(&field), &mut ctx); assert_eq!(result.unwrap().to_data(), expected.to_data()); } diff --git a/vortex-arrow/src/executor/run_end.rs b/vortex-arrow/src/executor/run_end.rs index cbe0e0c6f3b..ef8a124eef7 100644 --- a/vortex-arrow/src/executor/run_end.rs +++ b/vortex-arrow/src/executor/run_end.rs @@ -219,7 +219,7 @@ mod tests { use crate::executor::run_end::RunEnd; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); vortex_runend::initialize(&session); session }); diff --git a/vortex-arrow/src/executor/struct_.rs b/vortex-arrow/src/executor/struct_.rs index 3e2e8bd79ed..76946d8f01a 100644 --- a/vortex-arrow/src/executor/struct_.rs +++ b/vortex-arrow/src/executor/struct_.rs @@ -213,6 +213,7 @@ fn create_from_fields( #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use arrays::varbinview::VarBinViewArray; use arrow_array::Array; @@ -227,7 +228,6 @@ mod tests { use arrow_schema::Field; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; @@ -238,14 +238,17 @@ mod tests { use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::ArrowArrayExecutor; use crate::convert::from_arrow_dyn; use crate::dtype::to_data_type_naive; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn struct_nullable_non_null_to_arrow() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let xs = PrimitiveArray::new(buffer![0i64, 1, 2, 3, 4], Validity::AllValid); let struct_a = StructArray::try_new( @@ -272,7 +275,7 @@ mod tests { #[test] fn struct_nullable_with_nulls_to_arrow() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let xs = PrimitiveArray::from_option_iter(vec![Some(0_i64), Some(1), Some(2), None, Some(3)]); @@ -300,7 +303,7 @@ mod tests { #[test] fn struct_to_arrow_with_schema_mismatch() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let xs = PrimitiveArray::new(buffer![0i64, 1, 2, 3, 4], Validity::AllValid); let struct_a = StructArray::try_new( @@ -330,7 +333,7 @@ mod tests { #[test] fn test_to_arrow() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = StructArray::from_fields( vec![ ( @@ -373,7 +376,7 @@ mod tests { #[test] fn mask_wrapped_struct_exports_via_struct_fast_path() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // A struct behind a lazy `mask` scalar-fn nulling out row 1 — the shape a scan // produces when a row mask is applied to a top-level struct batch. let xs = PrimitiveArray::new(buffer![1i64, 2, 3], Validity::NonNullable); @@ -407,7 +410,7 @@ mod tests { #[test] fn to_arrow_with_non_nullable_fields() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = StructArray::from_fields( vec![ ( diff --git a/vortex-arrow/src/options/tests.rs b/vortex-arrow/src/options/tests.rs index 27594022e5c..d8241cf213b 100644 --- a/vortex-arrow/src/options/tests.rs +++ b/vortex-arrow/src/options/tests.rs @@ -2,6 +2,7 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::AtomicU32; use std::sync::atomic::Ordering; @@ -22,7 +23,6 @@ use vortex_array::ArrayRef; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::DictArray; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::ListArray; @@ -35,6 +35,7 @@ use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_runend::RunEnd; +use vortex_session::VortexSession; use vortex_session::registry::CachedId; use vortex_session::registry::Id; @@ -44,6 +45,8 @@ use crate::ArrowExportVTable; use crate::ArrowSession; use crate::ArrowSessionExt; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn typed_options_are_independent() { struct CustomOption(u32); @@ -123,7 +126,7 @@ impl ArrowExportVTable for Plugin { #[test] fn external_options_reach_nested_exporters() -> VortexResult<()> { - let session = array_session(); + let session = VortexSession::empty(); session.arrow().register_exporter(Arc::new(Plugin)); let mut ctx = session.create_execution_ctx(); let child = Field::new("item", DataType::Int32, false).with_metadata( @@ -309,8 +312,7 @@ fn compaction_option_reaches_nested_views( #[values(false, true)] binary: bool, #[values(None, Some(false), Some(true))] compact: Option, ) -> VortexResult<()> { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let options = compact.map_or_else(ArrowExportOptions::default, |compact| { ArrowExportOptions::default().with(CompactBuffers(compact)) }); @@ -320,7 +322,7 @@ fn compaction_option_reaches_nested_views( let expected = expected_sparse_views(binary); let (array, target) = shape.wrap(view.into_array(), expected.data_type().clone(), &mut ctx)?; - let arrow = session.arrow().exporter(&options).execute_arrow( + let arrow = SESSION.arrow().exporter(&options).execute_arrow( array, Some(&Field::new("", target, true)), &mut ctx, @@ -337,12 +339,11 @@ fn compaction_option_reaches_nested_views( #[rstest] fn execute_arrow_compacts_by_default(#[values(false, true)] binary: bool) -> VortexResult<()> { - let session = array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let view = sparse_views(binary, &mut ctx)?; let backing = view.data_buffers()[0].as_host().as_ptr(); - let arrow = session + let arrow = SESSION .arrow() .execute_arrow(view.into_array(), None, &mut ctx)?; diff --git a/vortex-arrow/src/run_end_import.rs b/vortex-arrow/src/run_end_import.rs index d92c6b6c5a8..abae401f506 100644 --- a/vortex-arrow/src/run_end_import.rs +++ b/vortex-arrow/src/run_end_import.rs @@ -98,7 +98,7 @@ mod tests { use crate::ArrowSessionExt; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); vortex_runend::initialize(&session); session }); diff --git a/vortex-arrow/src/session.rs b/vortex-arrow/src/session.rs index 18af691ef1a..32108a4f599 100644 --- a/vortex-arrow/src/session.rs +++ b/vortex-arrow/src/session.rs @@ -557,13 +557,13 @@ impl ArrowSession { /// use arrow_array::Array; /// use vortex_array::IntoArray; /// use vortex_array::VortexSessionExecute; - /// use vortex_array::array_session; + /// use vortex_session::VortexSession; /// use vortex_array::arrays::VarBinViewArray; /// use vortex_arrow::ArrowExportOptions; /// use vortex_arrow::ArrowSessionExt; /// use vortex_arrow::CompactBuffers; /// - /// let session = array_session(); + /// let session = VortexSession::empty(); /// let array = VarBinViewArray::from_iter_str(["a", "b"]).into_array(); /// let options = ArrowExportOptions::default().with(CompactBuffers(false)); /// let arrow = session.arrow().exporter(&options).execute_arrow( @@ -939,6 +939,7 @@ impl ArrowSessionExt for S { mod tests { use std::ops::Range; use std::sync::Arc; + use std::sync::LazyLock; use arrow_array::DictionaryArray; use arrow_array::GenericListArray; @@ -958,7 +959,6 @@ mod tests { use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute as _; - use vortex_array::array_session; use vortex_array::arrays::Dict; use vortex_array::arrays::ListArray; use vortex_array::arrays::PrimitiveArray; @@ -969,10 +969,13 @@ mod tests { use vortex_array::dtype::PType; use vortex_array::validity::Validity; use vortex_error::VortexResult; + use vortex_session::VortexSession; use vortex_session::registry::CachedId; use super::*; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::prefix(0, 2)] #[case::middle(500, 2)] @@ -1009,7 +1012,7 @@ mod tests { let sliced = session.from_arrow_array(lists(0..1000).slice(start, len), false)?; let fresh = session.from_arrow_array(lists(start as i64..(start + len) as i64), false)?; assert_eq!(sliced.nbytes(), fresh.nbytes()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = ListArray::new( PrimitiveArray::from_iter( (start as i64..(start + len) as i64).flat_map(|row| [row, row + 1]), @@ -1090,7 +1093,7 @@ mod tests { assert_arrays_eq!( array, VarBinViewArray::from_iter_str(["a", "b", "a", "b"]), - &mut array_session().create_execution_ctx() + &mut SESSION.create_execution_ctx() ); Ok(()) } diff --git a/vortex-arrow/tests/canonical.rs b/vortex-arrow/tests/canonical.rs index 54fae86c496..d18a35b1880 100644 --- a/vortex-arrow/tests/canonical.rs +++ b/vortex-arrow/tests/canonical.rs @@ -32,7 +32,7 @@ use vortex_buffer::buffer; use vortex_session::VortexSession; /// A shared session for these canonical tests, used to create execution contexts. -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); #[test] fn test_canonicalize_nested_struct() { diff --git a/vortex-bench/src/vector_dataset/convert.rs b/vortex-bench/src/vector_dataset/convert.rs index de37740ac12..7f21d8c1596 100644 --- a/vortex-bench/src/vector_dataset/convert.rs +++ b/vortex-bench/src/vector_dataset/convert.rs @@ -225,7 +225,6 @@ mod tests { use vortex::array::EmptyMetadata; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; - use vortex::array::array_session; use vortex::array::arrays::BoolArray; use vortex::array::arrays::ChunkedArray; use vortex::array::arrays::ExtensionArray; @@ -262,7 +261,7 @@ mod tests { dim: usize, element_validity: Validity, ) -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( values.len() % dim, 0, @@ -284,7 +283,7 @@ mod tests { } fn list_f32(rows: &[&[f32]]) -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut elements = BufferMut::::with_capacity(rows.iter().map(|r| r.len()).sum()); let mut offsets = BufferMut::::with_capacity(rows.len() + 1); offsets.push(0); @@ -359,7 +358,7 @@ mod tests { /// `list_to_vector_ext` fast-path that collapses `ListView` → `List` before /// validating offsets. fn list_view_f32(dim: usize, rows: &[&[f32]]) -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut values = BufferMut::::with_capacity(rows.len() * dim); for row in rows { assert_eq!(row.len(), dim); @@ -409,7 +408,7 @@ mod tests { #[test] fn all_invalid_list_validity_is_rejected() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // A list with `Validity::AllInvalid` means every row is null. The Vector // extension type requires non-nullable elements at the FSL level, so we // must reject this input rather than silently dropping the validity mask. @@ -435,7 +434,7 @@ mod tests { #[test] fn non_float_element_type_is_rejected() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Build a List. let elements = PrimitiveArray::new::( BufferMut::::from_iter([1i32, 2, 3, 4]).freeze(), diff --git a/vortex-btrblocks/benches/compress.rs b/vortex-btrblocks/benches/compress.rs index 3ad8c783d8d..974824ebd38 100644 --- a/vortex-btrblocks/benches/compress.rs +++ b/vortex-btrblocks/benches/compress.rs @@ -18,13 +18,29 @@ mod benchmarks { use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; + use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; + use vortex_array::dtype::session::DTypeSession; + use vortex_array::memory::MemorySession; + use vortex_array::optimizer::kernels::KernelSession; + use vortex_array::scalar_fn::session::ScalarFnSession; + use vortex_array::session::ArraySession; + use vortex_array::stats::session::StatsSession; use vortex_btrblocks::BtrBlocksCompressorBuilder; use vortex_buffer::buffer_mut; use vortex_session::VortexSession; use vortex_utils::aliases::hash_set::HashSet; - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + pub(super) static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + }); fn make_clickbench_window_name() -> ArrayRef { // A test that's meant to mirror the WindowName column from ClickBench. @@ -70,5 +86,7 @@ mod benchmarks { static GLOBAL: MiMalloc = MiMalloc; fn main() { + #[cfg(not(codspeed))] + std::sync::LazyLock::force(&benchmarks::SESSION); divan::main() } diff --git a/vortex-btrblocks/benches/compress_listview.rs b/vortex-btrblocks/benches/compress_listview.rs index 022d800ced2..43ff8892167 100644 --- a/vortex-btrblocks/benches/compress_listview.rs +++ b/vortex-btrblocks/benches/compress_listview.rs @@ -19,10 +19,17 @@ mod benchmarks { use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; + use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ListViewArray; use vortex_array::arrays::StructArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::dtype::FieldNames; + use vortex_array::dtype::session::DTypeSession; + use vortex_array::memory::MemorySession; + use vortex_array::optimizer::kernels::KernelSession; + use vortex_array::scalar_fn::session::ScalarFnSession; + use vortex_array::session::ArraySession; + use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_btrblocks::BtrBlocksCompressorBuilder; use vortex_buffer::buffer_mut; @@ -31,7 +38,16 @@ mod benchmarks { const NUM_ROWS: usize = 8192; const SEED: u64 = 42; - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + pub(super) static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + }); const SHORT_STRINGS: &[&str] = &[ "alpha_one", @@ -200,5 +216,7 @@ mod benchmarks { static GLOBAL: MiMalloc = MiMalloc; fn main() { + #[cfg(not(codspeed))] + std::sync::LazyLock::force(&benchmarks::SESSION); divan::main() } diff --git a/vortex-btrblocks/src/builder.rs b/vortex-btrblocks/src/builder.rs index 93179dab638..7123b58512f 100644 --- a/vortex-btrblocks/src/builder.rs +++ b/vortex-btrblocks/src/builder.rs @@ -247,6 +247,8 @@ impl BtrBlocksCompressorBuilder { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayId; use vortex_array::VTable; @@ -263,6 +265,9 @@ mod tests { use crate::schemes::decimal::DECIMAL_V1; use crate::schemes::decimal::DECIMAL_V2; + static SESSION: LazyLock = + LazyLock::new(|| VortexSession::empty().with::()); + #[rstest] #[case::fsst_missing_codes(&string::FSSTScheme, vec![FSST.id()], false)] #[case::fsst_with_codes(&string::FSSTScheme, vec![FSST.id(), VarBin.id()], true)] @@ -296,8 +301,7 @@ mod tests { #[test] fn delta_is_excluded_only_by_cuda() { - let session = VortexSession::empty().with::(); - let builder = BtrBlocksCompressorBuilder::from_session(&session).unrestricted(); + let builder = BtrBlocksCompressorBuilder::from_session(&SESSION).unrestricted(); let has_delta = |builder: BtrBlocksCompressorBuilder| { builder .allowed_schemes() diff --git a/vortex-btrblocks/src/lib.rs b/vortex-btrblocks/src/lib.rs index 668a563f9be..18a5847198a 100644 --- a/vortex-btrblocks/src/lib.rs +++ b/vortex-btrblocks/src/lib.rs @@ -40,7 +40,8 @@ //! # Example //! //! ```rust -//! use vortex_array::{IntoArray, VortexSessionExecute, array_session}; +//! use vortex_array::{IntoArray, VortexSessionExecute}; +//! use vortex_session::VortexSession; //! use vortex_array::arrays::PrimitiveArray; //! use vortex_array::validity::Validity; //! use vortex_btrblocks::{BtrBlocksCompressor, BtrBlocksCompressorBuilder, Scheme, SchemeExt}; @@ -48,7 +49,7 @@ //! use vortex_buffer::buffer; //! //! # fn example() -> vortex_error::VortexResult<()> { -//! let session = array_session(); +//! let session = VortexSession::empty(); //! let array = PrimitiveArray::new(buffer![42u64; 1024], Validity::NonNullable).into_array(); //! //! // Only schemes producing encodings the session registers and its enabled editions permit @@ -97,7 +98,7 @@ pub use vortex_compressor::stats::StringStats; #[cfg(test)] static SESSION: std::sync::LazyLock = - std::sync::LazyLock::new(vortex_array::array_session); + std::sync::LazyLock::new(vortex_session::VortexSession::empty); #[cfg(test)] mod tests; diff --git a/vortex-btrblocks/src/tests.rs b/vortex-btrblocks/src/tests.rs index 85435d21d29..03250fc4491 100644 --- a/vortex-btrblocks/src/tests.rs +++ b/vortex-btrblocks/src/tests.rs @@ -20,7 +20,6 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::aggregate_fn::fns::sum::sum; -use vortex_array::array_session; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::ListArray; use vortex_array::arrays::PrimitiveArray; @@ -45,6 +44,7 @@ use vortex_edition::EditionSessionExt; use vortex_edition::declarations::core::CORE_2026_08_3; use vortex_error::VortexResult; use vortex_fastlanes::Delta; +use vortex_session::VortexSession; use crate::BtrBlocksCompressor; use crate::BtrBlocksCompressorBuilder; @@ -61,7 +61,7 @@ fn assert_roundtrip(compressor: &BtrBlocksCompressor, input: &ArrayRef) -> Vorte #[test] fn test_default_compressor_roundtrip() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let integers = PrimitiveArray::from_option_iter( (0..2048i32).map(|i| (i % 7 != 0).then_some(1_000_000 + (i * 37) % 100)), ); @@ -157,7 +157,7 @@ fn test_cuda_binary_zstd_follows_editions( let input = VarBinViewArray::from_iter_bin(values.iter().map(Vec::as_slice)).into_array(); // The CUDA preset enables both Zstd schemes; the edition filter must choose between them. - let session = array_session(); + let session = VortexSession::empty(); vortex_zstd::initialize(&session); for family in EDITION_FAMILIES { session.editions().declare_family(family)?; diff --git a/vortex-btrblocks/tests/bitpacking_config.rs b/vortex-btrblocks/tests/bitpacking_config.rs index 0fe0323bfa9..3e0eca1d850 100644 --- a/vortex-btrblocks/tests/bitpacking_config.rs +++ b/vortex-btrblocks/tests/bitpacking_config.rs @@ -37,7 +37,7 @@ static BITPACKING_V1: BitPackingScheme = BitPackingScheme::v1(); /// Registers the fastlanes encodings, and enables no editions. static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.arrays().register(Patched); vortex_fastlanes::initialize(&session); session @@ -46,7 +46,7 @@ static SESSION: LazyLock = LazyLock::new(|| { /// Like [`SESSION`], with the latest core edition enabled: it allows `fastlanes.bitpacked` but not /// `fastlanes.bitpacked.v2`. static CORE_SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session().with::(); + let session = VortexSession::empty().with::(); for family in EDITION_FAMILIES { session .editions() diff --git a/vortex-btrblocks/tests/decimal_config.rs b/vortex-btrblocks/tests/decimal_config.rs index 749aebc561b..257d1b1aa60 100644 --- a/vortex-btrblocks/tests/decimal_config.rs +++ b/vortex-btrblocks/tests/decimal_config.rs @@ -49,7 +49,7 @@ static BITPACKING_V1: BitPackingScheme = BitPackingScheme::v1(); /// Registers the decimal and fastlanes encodings, and enables no editions. static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); vortex_decimal_byte_parts::initialize(&session); vortex_fastlanes::initialize(&session); session @@ -57,7 +57,7 @@ static SESSION: LazyLock = LazyLock::new(|| { /// Like [`SESSION`], with the latest core edition enabled: it allows decimal v1 but not v2. static CORE_SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session().with::(); + let session = VortexSession::empty().with::(); for family in EDITION_FAMILIES { session .editions() diff --git a/vortex-btrblocks/tests/for_config.rs b/vortex-btrblocks/tests/for_config.rs index 9df60c6535f..2c2bd76a063 100644 --- a/vortex-btrblocks/tests/for_config.rs +++ b/vortex-btrblocks/tests/for_config.rs @@ -37,7 +37,7 @@ static BITPACKING: BitPackingScheme = BitPackingScheme::v1(); /// Registers the fastlanes encodings, and enables no editions. static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); vortex_fastlanes::initialize(&session); session }); @@ -45,7 +45,7 @@ static SESSION: LazyLock = LazyLock::new(|| { /// Like [`SESSION`], with the latest core edition enabled: it allows `fastlanes.for` but not /// `fastlanes.for.v2`. static CORE_SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session().with::(); + let session = VortexSession::empty().with::(); for family in EDITION_FAMILIES { session .editions() diff --git a/vortex-btrblocks/tests/golden.rs b/vortex-btrblocks/tests/golden.rs index 93b936d214e..17932f5e6d7 100644 --- a/vortex-btrblocks/tests/golden.rs +++ b/vortex-btrblocks/tests/golden.rs @@ -63,7 +63,7 @@ use vortex_edition::declarations::core::CORE_2026_08_3; use vortex_error::VortexResult; use vortex_session::VortexSession; -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); /// Number of values in each numeric corpus entry: comfortably above the 1024-value sampling /// threshold so scheme selection runs on sampled estimates, as it does for real file chunks. @@ -440,7 +440,7 @@ fn without_onpair(builder: BtrBlocksCompressorBuilder) -> BtrBlocksCompressorBui } fn edition_session(editions: &[EditionId]) -> VortexResult { - let session = vortex_array::array_session().with::(); + let session = VortexSession::empty().with::(); // The compressor only produces encodings registered on the session. vortex_alp::initialize(&session); vortex_datetime_parts::initialize(&session); diff --git a/vortex-cloud/Cargo.toml b/vortex-cloud/Cargo.toml index c06453db36c..3da0e4c2262 100644 --- a/vortex-cloud/Cargo.toml +++ b/vortex-cloud/Cargo.toml @@ -37,6 +37,7 @@ vortex-error = { workspace = true, features = ["object_store"] } vortex-file = { workspace = true, features = ["object_store", "tokio"] } vortex-io = { workspace = true, features = ["object_store", "tokio"] } vortex-layout = { workspace = true } +vortex-session = { workspace = true } [features] default = [] diff --git a/vortex-cloud/src/registry/tests.rs b/vortex-cloud/src/registry/tests.rs index 2fb218f8af4..0566e0386de 100644 --- a/vortex-cloud/src/registry/tests.rs +++ b/vortex-cloud/src/registry/tests.rs @@ -8,6 +8,7 @@ use object_store::ObjectStore; use object_store::path::Path; use object_store::registry::ObjectStoreRegistry; use url::Url; +use vortex_session::VortexSession; use super::Registry; @@ -267,7 +268,7 @@ async fn test_resolved_key_reaches_the_object( use vortex_error::VortexError; use vortex_file::OpenOptionsSessionExt; - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::(); diff --git a/vortex-compressor/benches/dict_encode.rs b/vortex-compressor/benches/dict_encode.rs index c3e3a7b7251..4543b74e1b4 100644 --- a/vortex-compressor/benches/dict_encode.rs +++ b/vortex-compressor/benches/dict_encode.rs @@ -9,15 +9,30 @@ use divan::Bencher; use mimalloc::MiMalloc; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::builders::dict::dict_encode; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BufferMut; use vortex_session::VortexSession; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn make_array() -> PrimitiveArray { let values: BufferMut = (0..50).cycle().take(64_000).collect(); diff --git a/vortex-compressor/benches/float_stats.rs b/vortex-compressor/benches/float_stats.rs index 29c191a64a6..52a8e45dbd1 100644 --- a/vortex-compressor/benches/float_stats.rs +++ b/vortex-compressor/benches/float_stats.rs @@ -9,7 +9,14 @@ use divan::Bencher; use mimalloc::MiMalloc; use rand::prelude::*; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_buffer::Buffer; @@ -20,11 +27,21 @@ use vortex_session::VortexSession; #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const LEN: usize = 64 * 1024; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-compressor/benches/integer_stats.rs b/vortex-compressor/benches/integer_stats.rs index 6a2b52ffa6c..2fab379a7ee 100644 --- a/vortex-compressor/benches/integer_stats.rs +++ b/vortex-compressor/benches/integer_stats.rs @@ -9,7 +9,14 @@ use divan::Bencher; use mimalloc::MiMalloc; use rand::prelude::*; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_buffer::Buffer; @@ -20,11 +27,21 @@ use vortex_session::VortexSession; #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); const LEN: usize = 64 * 1024; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-compressor/benches/stats_calc.rs b/vortex-compressor/benches/stats_calc.rs index 069f58229f4..7a7d2e78bcf 100644 --- a/vortex-compressor/benches/stats_calc.rs +++ b/vortex-compressor/benches/stats_calc.rs @@ -11,15 +11,31 @@ mod benchmarks { use divan::Bencher; use num_traits::AsPrimitive; use vortex_array::VortexSessionExecute; + use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::NativePType; + use vortex_array::dtype::session::DTypeSession; + use vortex_array::memory::MemorySession; + use vortex_array::optimizer::kernels::KernelSession; + use vortex_array::scalar_fn::session::ScalarFnSession; + use vortex_array::session::ArraySession; + use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_compressor::stats::GenerateStatsOptions; use vortex_compressor::stats::IntegerStats; use vortex_session::VortexSession; - static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); + pub(super) static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + }); const LEN: usize = 64_000; @@ -113,5 +129,7 @@ mod benchmarks { static GLOBAL: MiMalloc = MiMalloc; fn main() { + #[cfg(not(codspeed))] + std::sync::LazyLock::force(&benchmarks::SESSION); divan::main(); } diff --git a/vortex-compressor/src/builtins/dict/float.rs b/vortex-compressor/src/builtins/dict/float.rs index c8067b9ac90..92dfc01ec5c 100644 --- a/vortex-compressor/src/builtins/dict/float.rs +++ b/vortex-compressor/src/builtins/dict/float.rs @@ -254,6 +254,8 @@ impl_encode!(f64, u64); #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::arrays::BoolArray; @@ -263,14 +265,17 @@ mod tests { use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::dictionary_encode; use crate::stats::FloatStats; use crate::stats::GenerateStatsOptions; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_float_dict_encode() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = buffer![1f32, 2f32, 2f32, 0f32, 1f32]; let validity = Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array()); diff --git a/vortex-compressor/src/builtins/dict/integer.rs b/vortex-compressor/src/builtins/dict/integer.rs index 765d9b41bad..9e621719b9a 100644 --- a/vortex-compressor/src/builtins/dict/integer.rs +++ b/vortex-compressor/src/builtins/dict/integer.rs @@ -261,6 +261,8 @@ impl_encode!(i64); #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::arrays::BoolArray; @@ -270,13 +272,16 @@ mod tests { use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::dictionary_encode; use crate::stats::IntegerStats; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_dict_encode_integer_stats() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let data = buffer![100i32, 200, 100, 0, 100]; let validity = Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array()); diff --git a/vortex-compressor/src/compressor/constant/tests.rs b/vortex-compressor/src/compressor/constant/tests.rs index 5f47d35b216..8a160f3d533 100644 --- a/vortex-compressor/src/compressor/constant/tests.rs +++ b/vortex-compressor/src/compressor/constant/tests.rs @@ -44,7 +44,7 @@ use crate::builtins::FloatDictScheme; use crate::builtins::IntDictScheme; use crate::builtins::StringDictScheme; -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); /// Constant detection is built into the compressor, so it must work with no schemes at all. fn empty_compressor() -> CascadingCompressor { diff --git a/vortex-compressor/src/compressor/sample.rs b/vortex-compressor/src/compressor/sample.rs index adfa5846e79..4f44dd330fc 100644 --- a/vortex-compressor/src/compressor/sample.rs +++ b/vortex-compressor/src/compressor/sample.rs @@ -193,20 +193,24 @@ pub(super) fn estimate_compression_ratio_with_sampling( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::*; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn sample_is_deterministic() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Create a deterministic array with linear-with-noise pattern let values: Vec = (0i64..100_000).map(|i| i + (i * 7 + 3) % 11).collect(); diff --git a/vortex-compressor/src/compressor/tests.rs b/vortex-compressor/src/compressor/tests.rs index 8ced45f268a..95418d443b3 100644 --- a/vortex-compressor/src/compressor/tests.rs +++ b/vortex-compressor/src/compressor/tests.rs @@ -64,7 +64,7 @@ use crate::scheme::SchemeExt; use crate::stats::ArrayAndStats; use crate::stats::GenerateStatsOptions; -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); fn compressor() -> CascadingCompressor { CascadingCompressor::new(vec![&IntDictScheme, &FloatDictScheme, &StringDictScheme]) diff --git a/vortex-compressor/src/lib.rs b/vortex-compressor/src/lib.rs index 55bb9b188f6..71476e7ab0a 100644 --- a/vortex-compressor/src/lib.rs +++ b/vortex-compressor/src/lib.rs @@ -24,14 +24,15 @@ //! compression is selected. //! //! ```rust -//! use vortex_array::{IntoArray, VortexSessionExecute, array_session}; +//! use vortex_array::{IntoArray, VortexSessionExecute}; +//! use vortex_session::VortexSession; //! use vortex_array::arrays::PrimitiveArray; //! use vortex_array::validity::Validity; //! use vortex_buffer::buffer; //! use vortex_compressor::CascadingCompressor; //! //! # fn example() -> vortex_error::VortexResult<()> { -//! let session = array_session(); +//! let session = VortexSession::empty(); //! let array = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable).into_array(); //! let compressor = CascadingCompressor::new(Vec::new()); //! diff --git a/vortex-compressor/src/stats/bool.rs b/vortex-compressor/src/stats/bool.rs index 31ef00078ac..6374b3f44cd 100644 --- a/vortex-compressor/src/stats/bool.rs +++ b/vortex-compressor/src/stats/bool.rs @@ -92,18 +92,22 @@ impl BoolStats { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::BoolStats; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_all_true() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = BoolArray::new( BitBuffer::from(vec![true, true, true]), Validity::NonNullable, @@ -118,7 +122,7 @@ mod tests { #[test] fn test_all_false() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = BoolArray::new( BitBuffer::from(vec![false, false, false]), Validity::NonNullable, @@ -133,7 +137,7 @@ mod tests { #[test] fn test_mixed() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = BoolArray::new( BitBuffer::from(vec![true, false, true]), Validity::NonNullable, @@ -148,7 +152,7 @@ mod tests { #[test] fn test_with_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = BoolArray::new( BitBuffer::from(vec![true, true, true]), Validity::from_iter([true, false, true]), diff --git a/vortex-compressor/src/stats/float.rs b/vortex-compressor/src/stats/float.rs index c505993e9e5..5b243f38dca 100644 --- a/vortex-compressor/src/stats/float.rs +++ b/vortex-compressor/src/stats/float.rs @@ -275,20 +275,24 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::FloatStats; use crate::stats::GenerateStatsOptions; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_float_stats() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let floats = buffer![0.0f32, 1.0f32, 2.0f32].into_array(); let floats = floats.execute::(&mut ctx)?; @@ -309,7 +313,7 @@ mod tests { #[test] fn test_float_stats_leading_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let floats = PrimitiveArray::new( buffer![0.0f32, 1.0f32, 2.0f32], Validity::from_iter([false, true, true]), diff --git a/vortex-compressor/src/stats/integer.rs b/vortex-compressor/src/stats/integer.rs index 2412ddf6450..db4096687e6 100644 --- a/vortex-compressor/src/stats/integer.rs +++ b/vortex-compressor/src/stats/integer.rs @@ -690,25 +690,28 @@ fn forward_fill(values: &[T; 64], valid: u64, prev: T) -> [T; 64] { #[cfg(test)] mod tests { use std::iter; + use std::sync::LazyLock; use rstest::rstest; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; use vortex_buffer::Buffer; use vortex_buffer::buffer; use vortex_error::VortexResult; + use vortex_session::VortexSession; use vortex_utils::aliases::hash_map::HashMap; use super::ErasedStats; use super::IntegerStats; use super::typed_int_stats; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_naive_count_distinct_values() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new(buffer![217u8, 0], Validity::NonNullable); let stats = typed_int_stats::(&array, true, &mut ctx)?; assert_eq!(stats.distinct_count().unwrap(), 2); @@ -717,7 +720,7 @@ mod tests { #[test] fn test_naive_count_distinct_values_nullable() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new( buffer![217u8, 0], Validity::from(BitBuffer::from(vec![true, false])), @@ -729,7 +732,7 @@ mod tests { #[test] fn test_count_distinct_values() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new((0..128u8).collect::>(), Validity::NonNullable); let stats = typed_int_stats::(&array, true, &mut ctx)?; assert_eq!(stats.distinct_count().unwrap(), 128); @@ -738,7 +741,7 @@ mod tests { #[test] fn test_count_distinct_values_nullable() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new( (0..128u8).collect::>(), Validity::from(BitBuffer::from_iter( @@ -752,7 +755,7 @@ mod tests { #[test] fn dense_distinct_signed_full_range() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values: Buffer = (i8::MIN..=i8::MAX) .chain(i8::MIN..=i8::MAX) .chain(iter::once(i8::MAX)) @@ -770,7 +773,7 @@ mod tests { #[test] fn dense_distinct_ignores_values_under_nulls() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new( buffer![1000i32, 1001, 1000, 5_000_000, 1003], Validity::from_iter([true, true, true, false, true]), @@ -787,7 +790,7 @@ mod tests { #[test] fn wide_range_distinct() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new(buffer![0u64, u64::MAX, 0], Validity::NonNullable); let stats = typed_int_stats::(&array, true, &mut ctx)?; @@ -801,7 +804,7 @@ mod tests { #[test] fn test_integer_stats_leading_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ints = PrimitiveArray::new(buffer![0, 1, 2], Validity::from_iter([false, true, true])); let stats = IntegerStats::generate_opts( @@ -856,7 +859,7 @@ mod tests { Some(_) => Validity::from(BitBuffer::from(valid)), }; let array = PrimitiveArray::new(Buffer::from(values), validity); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let stats = typed_int_stats::(&array, count_distinct_values, &mut ctx)?; let ErasedStats::U32(typed) = stats.erased() else { diff --git a/vortex-cuda/benches/alp_cuda.rs b/vortex-cuda/benches/alp_cuda.rs index 63816f1288c..3bc61242f50 100644 --- a/vortex-cuda/benches/alp_cuda.rs +++ b/vortex-cuda/benches/alp_cuda.rs @@ -12,6 +12,7 @@ mod timed_launch_strategy; use std::f64; use std::mem::size_of; use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::Ordering; use std::time::Duration; @@ -23,7 +24,6 @@ use futures::executor::block_on; use mimalloc::MiMalloc; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; -use vortex::array::array_session; use vortex::array::arrays::PrimitiveArray; use vortex::array::validity::Validity::NonNullable; use vortex::buffer::Buffer; @@ -33,6 +33,14 @@ use vortex::encodings::alp::ALPArrayExt; use vortex::encodings::alp::ALPFloat; use vortex::encodings::alp::alp_encode; use vortex::error::VortexExpect; +use vortex::session::VortexSession; +use vortex_array::aggregate_fn::session::AggregateFnSession; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_cuda::CudaDispatchMode; use vortex_cuda::CudaSession; use vortex_cuda::executor::CudaArrayExt; @@ -42,6 +50,18 @@ use vortex_cuda_macros::cuda_not_available; use crate::bench_config::BENCH_SIZES; use crate::timed_launch_strategy::TimedLaunchStrategy; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; @@ -78,7 +98,7 @@ where let encoded = alp_encode( primitive_array.as_view(), None, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .vortex_expect("failed to ALP-encode array"); @@ -145,7 +165,11 @@ criterion::criterion_group! { } #[cuda_available] -criterion::criterion_main!(benches); +fn main() { + LazyLock::force(&SESSION); + benches(); + Criterion::default().configure_from_args().final_summary(); +} #[cuda_not_available] fn main() {} diff --git a/vortex-cuda/benches/arrow_validity_cuda.rs b/vortex-cuda/benches/arrow_validity_cuda.rs index f3def0f679b..9bd501c3ea6 100644 --- a/vortex-cuda/benches/arrow_validity_cuda.rs +++ b/vortex-cuda/benches/arrow_validity_cuda.rs @@ -8,6 +8,7 @@ mod bench_config; mod timed_launch_strategy; use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::Ordering; use std::time::Duration; use std::time::Instant; @@ -28,6 +29,13 @@ use vortex::dtype::PType; use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::session::VortexSession; +use vortex_array::aggregate_fn::session::AggregateFnSession; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_cuda::CudaExecutionCtx; use vortex_cuda::CudaSession; use vortex_cuda::arrow::ArrowDeviceArray; @@ -38,6 +46,18 @@ use vortex_cuda_macros::cuda_not_available; use crate::timed_launch_strategy::TimedLaunchStrategy; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; @@ -109,9 +129,8 @@ fn benchmark_arrow_validity_export(c: &mut Criterion) { &len, |b, &len| { b.iter_custom(|iters| { - let mut cuda_ctx = - CudaSession::create_execution_ctx(&VortexSession::empty()) - .vortex_expect("failed to create execution context"); + let mut cuda_ctx = CudaSession::create_execution_ctx(&SESSION) + .vortex_expect("failed to create execution context"); let array = block_on(primitive_with_device_bool_validity( len, validity_offset, @@ -161,7 +180,7 @@ fn benchmark_arrow_validity_repack(c: &mut Criterion) { b.iter_custom(|iters| { let timed = TimedLaunchStrategy::default(); let timer = timed.timer(); - let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty()) + let mut cuda_ctx = CudaSession::create_execution_ctx(&SESSION) .vortex_expect("failed to create execution context") .with_launch_strategy(Arc::new(timed)); let (input_offset, input_buffer) = @@ -203,7 +222,7 @@ fn benchmark_arrow_validity_count_nulls(c: &mut Criterion) { b.iter_custom(|iters| { let timed = TimedLaunchStrategy::default(); let timer = timed.timer(); - let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty()) + let mut cuda_ctx = CudaSession::create_execution_ctx(&SESSION) .vortex_expect("failed to create execution context") .with_launch_strategy(Arc::new(timed)); let (_, input_buffer) = @@ -237,7 +256,11 @@ criterion::criterion_group! { } #[cuda_available] -criterion::criterion_main!(benches); +fn main() { + LazyLock::force(&SESSION); + benches(); + Criterion::default().configure_from_args().final_summary(); +} #[cuda_not_available] fn main() {} diff --git a/vortex-cuda/benches/bitpacked_cuda.rs b/vortex-cuda/benches/bitpacked_cuda.rs index f24904f4c2a..413ca0a0052 100644 --- a/vortex-cuda/benches/bitpacked_cuda.rs +++ b/vortex-cuda/benches/bitpacked_cuda.rs @@ -12,6 +12,7 @@ mod timed_launch_strategy; use std::mem::size_of; use std::ops::Add; use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::Ordering; use std::time::Duration; @@ -23,7 +24,6 @@ use futures::executor::block_on; use mimalloc::MiMalloc; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; -use vortex::array::array_session; use vortex::array::arrays::PrimitiveArray; use vortex::array::validity::Validity::NonNullable; use vortex::buffer::Buffer; @@ -32,6 +32,14 @@ use vortex::encodings::fastlanes::BitPackedArray; use vortex::encodings::fastlanes::BitPackedData; use vortex::encodings::fastlanes::unpack_iter::BitPacked; use vortex::error::VortexExpect; +use vortex::session::VortexSession; +use vortex_array::aggregate_fn::session::AggregateFnSession; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_cuda::CudaDispatchMode; use vortex_cuda::CudaSession; use vortex_cuda::executor::CudaArrayExt; @@ -40,6 +48,18 @@ use vortex_cuda_macros::cuda_not_available; use crate::timed_launch_strategy::TimedLaunchStrategy; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; @@ -61,7 +81,7 @@ where .collect(); let primitive_array = PrimitiveArray::new(Buffer::from(values), NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); BitPackedData::encode(&primitive_array.into_array(), bit_width, &mut ctx) .vortex_expect("failed to create BitPacked array") } @@ -102,7 +122,7 @@ where .collect(); let primitive_array = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); BitPackedData::encode(&primitive_array, bit_width, &mut ctx) .vortex_expect("failed to create BitPacked array with patches") } @@ -222,7 +242,11 @@ criterion::criterion_group! { } #[cuda_available] -criterion::criterion_main!(benches); +fn main() { + LazyLock::force(&SESSION); + benches(); + Criterion::default().configure_from_args().final_summary(); +} #[cuda_not_available] fn main() {} diff --git a/vortex-cuda/benches/delta_cuda.rs b/vortex-cuda/benches/delta_cuda.rs index 33de613a892..ce3263558dc 100644 --- a/vortex-cuda/benches/delta_cuda.rs +++ b/vortex-cuda/benches/delta_cuda.rs @@ -14,6 +14,7 @@ mod timed_launch_strategy; use std::mem::size_of; use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::Ordering; use std::time::Duration; @@ -25,7 +26,6 @@ use futures::executor::block_on; use mimalloc::MiMalloc; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; -use vortex::array::array_session; use vortex::array::arrays::PrimitiveArray; use vortex::array::validity::Validity; use vortex::buffer::Buffer; @@ -33,6 +33,14 @@ use vortex::dtype::NativePType; use vortex::encodings::fastlanes::Delta; use vortex::encodings::fastlanes::DeltaArray; use vortex::error::VortexExpect; +use vortex::session::VortexSession; +use vortex_array::aggregate_fn::session::AggregateFnSession; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_cuda::CudaDispatchMode; use vortex_cuda::CudaSession; use vortex_cuda::executor::CudaArrayExt; @@ -42,6 +50,18 @@ use vortex_cuda_macros::cuda_not_available; use crate::bench_config::BENCH_SIZES; use crate::timed_launch_strategy::TimedLaunchStrategy; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; @@ -56,7 +76,7 @@ where .collect(); let primitive = PrimitiveArray::new(Buffer::from(data), Validity::NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); Delta::try_from_primitive_array(&primitive, &mut ctx).vortex_expect("failed to delta encode") } @@ -112,7 +132,11 @@ criterion::criterion_group! { } #[cuda_available] -criterion::criterion_main!(benches); +fn main() { + LazyLock::force(&SESSION); + benches(); + Criterion::default().configure_from_args().final_summary(); +} #[cuda_not_available] fn main() {} diff --git a/vortex-cuda/benches/dynamic_dispatch_cuda.rs b/vortex-cuda/benches/dynamic_dispatch_cuda.rs index 50a4d959e09..d9f3303a37d 100644 --- a/vortex-cuda/benches/dynamic_dispatch_cuda.rs +++ b/vortex-cuda/benches/dynamic_dispatch_cuda.rs @@ -12,6 +12,7 @@ use std::mem::size_of; use std::os::raw::c_void; use std::ptr; use std::sync::Arc; +use std::sync::LazyLock; use std::time::Duration; use criterion::BenchmarkId; @@ -29,7 +30,6 @@ use mimalloc::MiMalloc; use vortex::array::ArrayRef; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; -use vortex::array::array_session; use vortex::array::arrays::DictArray; use vortex::array::arrays::PrimitiveArray; use vortex::array::buffer::BufferHandle; @@ -60,6 +60,14 @@ use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::error::vortex_err; use vortex::error::vortex_panic; +use vortex::session::VortexSession; +use vortex_array::aggregate_fn::session::AggregateFnSession; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_cuda::CudaBufferExt; use vortex_cuda::CudaDispatchMode; use vortex_cuda::CudaExecutionCtx; @@ -74,6 +82,18 @@ use vortex_cuda_macros::cuda_not_available; use crate::bench_config::BENCH_SIZES; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; @@ -221,7 +241,7 @@ fn bench_for_bitpacked(c: &mut Criterion) { .map(|i| (i as u64 % (max_val + 1)) as u32) .collect(); let prim = PrimitiveArray::new(Buffer::from(residuals), NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bp = BitPackedData::encode(&prim.into_array(), bit_width, &mut ctx).vortex_expect("bitpack"); let array = FoR::try_new(bp.into_array(), Scalar::from(reference)) @@ -266,7 +286,7 @@ fn bench_dict_bp_codes(c: &mut Criterion) { let codes: Vec = (0..*len).map(|i| (i % dict_size) as u32).collect(); let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let codes_bp = BitPackedData::encode(&codes_prim.into_array(), dict_bit_width, &mut ctx) .vortex_expect("bitpack codes"); let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable); @@ -311,7 +331,7 @@ fn bench_runend(c: &mut Criterion) { let ends: Vec = (1..=num_runs).map(|i| (i * run_len) as u32).collect(); let values: Vec = (0..num_runs).map(|i| (i * 7 + 42) as u32).collect(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ends_arr = PrimitiveArray::new(Buffer::from(ends), NonNullable).into_array(); let values_arr = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array(); let re = RunEnd::new(ends_arr, values_arr, &mut ctx); @@ -358,7 +378,7 @@ fn bench_dict_bp_codes_alp_for_bp_values_dynanmic_dispatch(c: &mut Criterion) { .map(|i| ::decode_single(10 + i as i32, exponents)) .collect(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // values: ALP → FoR → BitPacked. let float_prim = PrimitiveArray::new(Buffer::from(dict_floats), NonNullable); @@ -665,7 +685,7 @@ fn bench_dict_bp_codes_alp_for_bp_values_composed_standalone(c: &mut Criterion) .map(|i| ::decode_single(10 + (i as i32 % 64), exponents)) .collect(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let float_prim = PrimitiveArray::new(Buffer::from(dict_floats), NonNullable); let alp = alp_encode(float_prim.as_view(), Some(exponents), &mut ctx).vortex_expect("alp_encode"); @@ -733,7 +753,7 @@ fn bench_dict_bp_codes_alp_for_bp_values_composed_standalone(c: &mut Criterion) // Benchmark: ALP(FoR(BitPacked)) — f64 // --------------------------------------------------------------------------- fn bench_alp_for_bitpacked_f64(c: &mut Criterion) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut group = c.benchmark_group("cuda"); let exponents = Exponents { e: 2, f: 0 }; @@ -819,7 +839,7 @@ fn bench_dict_bp_codes_bp_for_values(c: &mut Criterion) { // Dict values: residuals 0..63 bitpacked, FoR adds 1_000_000 let dict_residuals: Vec = (0..dict_size as u32).collect(); let dict_prim = PrimitiveArray::new(Buffer::from(dict_residuals), NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict_bp = BitPackedData::encode(&dict_prim.into_array(), dict_bit_width, &mut ctx) .vortex_expect("bitpack dict"); let dict_for = @@ -866,7 +886,7 @@ fn bench_dict_bp_codes_bp_for_values(c: &mut Criterion) { // Benchmark: ALP(FoR(BitPacked)) for f32 // --------------------------------------------------------------------------- fn bench_alp_for_bitpacked(c: &mut Criterion) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut group = c.benchmark_group("cuda"); let exponents = Exponents { e: 2, f: 0 }; @@ -945,7 +965,7 @@ fn bench_dict_bp_u8_codes_u32_values(c: &mut Criterion) { let codes: Vec = (0..*len).map(|i| (i % dict_size) as u8).collect(); let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let codes_bp = BitPackedData::encode(&codes_prim.into_array(), bit_width, &mut ctx) .vortex_expect("bitpack u8 codes"); let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable); @@ -988,7 +1008,7 @@ fn bench_dict_bp_u16_codes_u32_values(c: &mut Criterion) { let codes: Vec = (0..*len).map(|i| (i % dict_size) as u16).collect(); let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let codes_bp = BitPackedData::encode(&codes_prim.into_array(), bit_width, &mut ctx) .vortex_expect("bitpack u16 codes"); let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable); @@ -1031,7 +1051,7 @@ fn bench_dict_bp_u32_codes_u32_values(c: &mut Criterion) { let codes: Vec = (0..*len).map(|i| (i % dict_size) as u32).collect(); let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let codes_bp = BitPackedData::encode(&codes_prim.into_array(), bit_width, &mut ctx) .vortex_expect("bitpack u32 codes"); let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable); @@ -1082,7 +1102,11 @@ criterion::criterion_group! { } #[cuda_available] -criterion::criterion_main!(benches); +fn main() { + LazyLock::force(&SESSION); + benches(); + Criterion::default().configure_from_args().final_summary(); +} #[cuda_not_available] fn main() {} diff --git a/vortex-cuda/benches/for_cuda.rs b/vortex-cuda/benches/for_cuda.rs index 630756956c4..919553874c4 100644 --- a/vortex-cuda/benches/for_cuda.rs +++ b/vortex-cuda/benches/for_cuda.rs @@ -12,6 +12,7 @@ mod timed_launch_strategy; use std::mem::size_of; use std::ops::Add; use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::Ordering; use std::time::Duration; @@ -23,7 +24,6 @@ use futures::executor::block_on; use mimalloc::MiMalloc; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; -use vortex::array::array_session; use vortex::array::arrays::PrimitiveArray; use vortex::array::validity::Validity; use vortex::buffer::Buffer; @@ -34,6 +34,14 @@ use vortex::encodings::fastlanes::FoR; use vortex::encodings::fastlanes::FoRArray; use vortex::error::VortexExpect; use vortex::scalar::Scalar; +use vortex::session::VortexSession; +use vortex_array::aggregate_fn::session::AggregateFnSession; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_cuda::CudaDispatchMode; use vortex_cuda::CudaSession; use vortex_cuda::executor::CudaArrayExt; @@ -43,6 +51,18 @@ use vortex_cuda_macros::cuda_not_available; use crate::bench_config::BENCH_SIZES; use crate::timed_launch_strategy::TimedLaunchStrategy; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; const REFERENCE_VALUE: u8 = 10; @@ -62,7 +82,7 @@ where PrimitiveArray::new(Buffer::from(data), Validity::NonNullable).into_array(); if bp && T::PTYPE != PType::U8 { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let child = BitPackedData::encode(&primitive_array, 8, &mut ctx).vortex_expect("failed to bitpack"); FoR::try_new(child.into_array(), reference.into()) @@ -176,7 +196,11 @@ criterion::criterion_group! { } #[cuda_available] -criterion::criterion_main!(benches); +fn main() { + LazyLock::force(&SESSION); + benches(); + Criterion::default().configure_from_args().final_summary(); +} #[cuda_not_available] fn main() {} diff --git a/vortex-cuda/benches/fsst_cuda.rs b/vortex-cuda/benches/fsst_cuda.rs index 784856c0585..cc9c1d43a79 100644 --- a/vortex-cuda/benches/fsst_cuda.rs +++ b/vortex-cuda/benches/fsst_cuda.rs @@ -9,6 +9,7 @@ mod bench_config; mod timed_launch_strategy; use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::Ordering; use std::time::Duration; @@ -19,14 +20,22 @@ use futures::executor::block_on; use mimalloc::MiMalloc; use vortex::array::ArrayRef; use vortex::array::IntoArray; +use vortex::array::aggregate_fn::session::AggregateFnSession; use vortex::array::arrays::PrimitiveArray; +use vortex::array::dtype::session::DTypeSession; use vortex::array::match_each_integer_ptype; +use vortex::array::memory::MemorySession; +use vortex::array::optimizer::kernels::KernelSession; +use vortex::array::scalar_fn::session::ScalarFnSession; +use vortex::array::session::ArraySession; +use vortex::array::stats::session::StatsSession; use vortex::dtype::DType; use vortex::dtype::Nullability; use vortex::encodings::fsst::FSST; use vortex::encodings::fsst::FSSTArrayExt; use vortex::encodings::fsst::FSSTArraySlotsExt; use vortex::error::VortexExpect; +use vortex::session::VortexSession; use vortex_cuda::CudaDispatchMode; use vortex_cuda::CudaSession; use vortex_cuda::VarBinExportLayout; @@ -48,12 +57,32 @@ static GLOBAL: MiMalloc = MiMalloc; // other kernels benchmark. const BENCH_SIZES: &[(usize, &str)] = &[(10_000_000, "10M")]; -fn session_with_varbin_layout(layout: VarBinExportLayout) -> vortex::session::VortexSession { - vortex::array::array_session().with_some( - CudaSession::try_default() - .vortex_expect("failed to create CUDA session") - .with_varbin_export_layout(layout), - ) +fn session_with_varbin_layout(layout: VarBinExportLayout) -> VortexSession { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with_some( + CudaSession::try_default() + .vortex_expect("failed to create CUDA session") + .with_varbin_export_layout(layout), + ) +} + +static VARBIN_SESSION: LazyLock = + LazyLock::new(|| session_with_varbin_layout(VarBinExportLayout::VarBin)); +static VARBINVIEW_SESSION: LazyLock = + LazyLock::new(|| session_with_varbin_layout(VarBinExportLayout::VarBinView)); + +fn session_for(layout: VarBinExportLayout) -> &'static VortexSession { + match layout { + VarBinExportLayout::VarBin => &VARBIN_SESSION, + VarBinExportLayout::VarBinView => &VARBINVIEW_SESSION, + } } struct FSSTBenchFixture { @@ -157,8 +186,7 @@ fn benchmark_fsst_cuda_decompress(c: &mut Criterion) { let timed = TimedLaunchStrategy::default(); let timer = timed.timer(); - let session = session_with_varbin_layout(layout); - let mut cuda_ctx = CudaSession::create_execution_ctx(&session) + let mut cuda_ctx = CudaSession::create_execution_ctx(session_for(layout)) .vortex_expect("failed to create execution context") .with_dispatch_mode(CudaDispatchMode::StandaloneOnly) .with_launch_strategy(Arc::new(timed)); @@ -186,7 +214,12 @@ criterion::criterion_group! { } #[cuda_available] -criterion::criterion_main!(benches); +fn main() { + LazyLock::force(&VARBIN_SESSION); + LazyLock::force(&VARBINVIEW_SESSION); + benches(); + Criterion::default().configure_from_args().final_summary(); +} #[cuda_not_available] fn main() {} diff --git a/vortex-cuda/src/arrow/canonical.rs b/vortex-cuda/src/arrow/canonical.rs index f48915716da..44e4b11f0b0 100644 --- a/vortex-cuda/src/arrow/canonical.rs +++ b/vortex-cuda/src/arrow/canonical.rs @@ -1453,6 +1453,7 @@ unsafe fn release_array_ptr(array: *mut ArrowArray) { mod tests { use std::mem::size_of; use std::sync::Arc; + use std::sync::LazyLock; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; @@ -1464,7 +1465,6 @@ mod tests { use vortex::array::ArrayRef; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; - use vortex::array::array_session; use vortex::array::arrays::BoolArray; use vortex::array::arrays::ChunkedArray; use vortex::array::arrays::DecimalArray; @@ -1504,6 +1504,7 @@ mod tests { use vortex::error::vortex_bail; use vortex::error::vortex_err; use vortex::extension::datetime::TimeUnit; + use vortex::session::VortexSession; use crate::CudaBufferExt; use crate::CudaDeviceBuffer; @@ -1529,6 +1530,8 @@ mod tests { use crate::session::CudaSession; use crate::session::VarBinExportLayout; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn device_bool( bits: BitBuffer, validity: Validity, @@ -1547,7 +1550,7 @@ mod tests { } fn cuda_ctx_with_varbin_layout(layout: VarBinExportLayout) -> VortexResult { - let session = array_session() + let session = VortexSession::empty() .with_some(CudaSession::try_default()?.with_varbin_export_layout(layout)); CudaSession::create_execution_ctx(&session) } @@ -1729,7 +1732,7 @@ mod tests { Arc::from([first, second]), dtype, Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), ) .vortex_expect("valid multi-buffer VarBinViewArray") .into_array(); diff --git a/vortex-cuda/src/arrow/dictionary_tests.rs b/vortex-cuda/src/arrow/dictionary_tests.rs index c69b5a887c0..facb6136682 100644 --- a/vortex-cuda/src/arrow/dictionary_tests.rs +++ b/vortex-cuda/src/arrow/dictionary_tests.rs @@ -1,6 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; use std::task::Poll; @@ -9,7 +10,6 @@ use futures::stream; use rstest::rstest; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; -use vortex::array::array_session; use vortex::array::arrays::Constant; use vortex::array::arrays::DictArray; use vortex::array::arrays::ListViewArray; @@ -24,12 +24,15 @@ use vortex::array::validity::Validity; use vortex::buffer::BitBuffer; use vortex::buffer::Buffer; use vortex::error::vortex_bail; +use vortex::session::VortexSession; use super::tests::last_error; use super::tests::private_data_buffer_bytes as buffer; use super::*; use crate::CudaSession; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Move all buffers, including validity, to CUDA without decoding, preventing CPU fallback. pub(super) fn upload(array: ArrayRef, ctx: &mut CudaExecutionCtx) -> VortexResult { // Constants store scalar metadata, not replaceable data buffers. @@ -80,7 +83,7 @@ fn read_plain(array: &ArrowArray, dtype: &DType) -> VortexResult { buffer(array, 2)?.slice_unaligned(..), dtype.clone(), validity, - &mut array_session().create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )? .into_array()) } @@ -180,7 +183,7 @@ fn test_decode_mixed_dictionary_device_stream( #[values(false, true)] schema_first: bool, ) -> VortexResult<()> { let runtime = CurrentThreadRuntime::new(); - let session = array_session() + let session = VortexSession::empty() .with_some(CudaSession::try_default()?.with_dictionary_export(DictionaryExport::Decode)); let mut ctx = CudaSession::create_execution_ctx(&session)?; let (values, expected) = values_and_expected(strings); @@ -238,7 +241,7 @@ fn test_decode_stream_schema_does_not_poll( #[case] consume: bool, ) -> VortexResult<()> { let runtime = CurrentThreadRuntime::new(); - let session = array_session() + let session = VortexSession::empty() .with_some(CudaSession::try_default()?.with_dictionary_export(DictionaryExport::Decode)); let array = PrimitiveArray::from_iter([10i32, 20, 30]).into_array(); let dtype = array.dtype().clone(); @@ -290,7 +293,7 @@ fn test_decode_stream_schema_does_not_poll( #[crate::test] fn test_decode_stream_validates_dtype_and_device() -> VortexResult<()> { let runtime = CurrentThreadRuntime::new(); - let session = array_session() + let session = VortexSession::empty() .with_some(CudaSession::try_default()?.with_dictionary_export(DictionaryExport::Decode)); let array = PrimitiveArray::from_iter([10i32, 20, 30]).into_array(); let mut stream = array @@ -323,7 +326,7 @@ fn test_decode_stream_validates_dtype_and_device() -> VortexResult<()> { #[crate::test] async fn test_decode_non_contiguous_dictionary_list_view() -> VortexResult<()> { - let session = array_session() + let session = VortexSession::empty() .with_some(CudaSession::try_default()?.with_dictionary_export(DictionaryExport::Decode)); let mut ctx = CudaSession::create_execution_ctx(&session)?; let (values, expected) = values_and_expected(true); @@ -362,7 +365,7 @@ async fn test_decode_non_contiguous_dictionary_list_view() -> VortexResult<()> { #[crate::test] async fn test_decode_unsupported_device_dictionary_does_not_fall_back_to_cpu() -> VortexResult<()> { - let session = array_session().with_some(CudaSession::try_default()?); + let session = VortexSession::empty().with_some(CudaSession::try_default()?); let mut ctx = CudaSession::create_execution_ctx(&session)?; // A dictionary of structs can be preserved, but has no CUDA gather kernel today. let (values, _) = values_and_expected(false); diff --git a/vortex-cuda/src/canonical.rs b/vortex-cuda/src/canonical.rs index 562ad241e98..138033a08ea 100644 --- a/vortex-cuda/src/canonical.rs +++ b/vortex-cuda/src/canonical.rs @@ -193,19 +193,23 @@ impl CanonicalCudaExt for Canonical { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex::array::VortexSessionExecute; - use vortex::array::array_session; use vortex::dtype::PType; + use vortex::session::VortexSession; use super::*; use crate::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[crate::test] async fn test_into_host_rejects_out_of_bounds_device_list_view() -> VortexResult<()> { let cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())?; let offsets = cuda_ctx.stream().copy_to_device(vec![0u32, 2])?.await?; let sizes = cuda_ctx.stream().copy_to_device(vec![2u32, 5])?.await?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // The second list reads elements 2..7 of 3. The range check is skipped while the offsets // and sizes are on the device, so it must run once they are copied to the host. let list = ListViewArray::try_new( diff --git a/vortex-cuda/src/device_buffer.rs b/vortex-cuda/src/device_buffer.rs index e5ffddac43e..19d23e7e2a1 100644 --- a/vortex-cuda/src/device_buffer.rs +++ b/vortex-cuda/src/device_buffer.rs @@ -518,6 +518,7 @@ mod tests { use vortex::dtype::PType; use vortex::error::VortexResult; use vortex::error::vortex_bail; + use vortex::session::VortexSession; use super::*; use crate::CudaSession; @@ -548,7 +549,7 @@ mod tests { let context = CudaContext::new(0) .map_err(|err| vortex_err!("failed to create CUDA context: {err}"))?; let cuda_session = CudaSession::with_stream_pool_capacity(context, 2); - let session = vortex::array::array_session().with_some(cuda_session); + let session = VortexSession::empty().with_some(cuda_session); let allocation_ctx = CudaSession::create_execution_ctx(&session)?; let mut launch_ctx = CudaSession::create_execution_ctx(&session)?; assert_ne!( diff --git a/vortex-cuda/src/dynamic_dispatch/mod.rs b/vortex-cuda/src/dynamic_dispatch/mod.rs index 5e66deb753d..0a031dc95ef 100644 --- a/vortex-cuda/src/dynamic_dispatch/mod.rs +++ b/vortex-cuda/src/dynamic_dispatch/mod.rs @@ -475,6 +475,7 @@ mod tests { use std::f32::consts::SQRT_2; use std::ops::Range; use std::sync::Arc; + use std::sync::LazyLock; use cudarc::driver::DevicePtr; use cudarc::driver::LaunchConfig; @@ -514,9 +515,9 @@ mod tests { use vortex::error::VortexResult; use vortex::error::vortex_bail; use vortex::mask::Mask; + use vortex::session::VortexSession; use vortex_array::ExecutionCtx; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::FilterArray; use vortex_array::assert_arrays_eq; use vortex_array::patches::Patches; @@ -531,6 +532,8 @@ mod tests { use crate::hybrid_dispatch::try_gpu_dispatch; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// The reference of a FoR array built by `FoR::encode`, which is always global. fn global_reference(array: &FoRArray) -> VortexResult { match array.references() { @@ -582,7 +585,7 @@ mod tests { #[crate::test] fn test_max_scalar_ops() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 6; let len = 2050; let references: [u32; 4] = [1, 2, 4, 8]; @@ -747,7 +750,7 @@ mod tests { #[crate::test] async fn test_bitpacked() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 10; let len = 3000; let max_val = (1u64 << bit_width).saturating_sub(1); @@ -768,7 +771,7 @@ mod tests { #[crate::test] async fn test_for_bitpacked() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 6; let len = 3000; let reference = 42u32; @@ -820,7 +823,7 @@ mod tests { #[crate::test] async fn test_dict_for_bp_values_bp_codes() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Dict where both codes and values are BitPacked+FoR. let dict_reference = 1_000_000u32; let dict_residuals: Vec = (0..64).collect(); @@ -854,7 +857,7 @@ mod tests { #[crate::test] async fn test_alp_for_bitpacked() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // ALP(FoR(BitPacked)): encode each layer, then reassemble the tree // bottom-up because encode() methods produce flat outputs. let len = 3000; @@ -890,7 +893,7 @@ mod tests { #[crate::test] async fn test_zigzag_bitpacked() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // ZigZag(BitPacked): unpack then zigzag-decode. let bit_width: u8 = 4; let len = 3000; @@ -978,7 +981,7 @@ mod tests { #[crate::test] async fn test_dict_for_bp_codes() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Dict(codes=FoR(BitPacked), values=primitive) let dict_values: Vec = (0..8).map(|i| i * 1000 + 7).collect(); let dict_size = dict_values.len(); @@ -1007,7 +1010,7 @@ mod tests { #[crate::test] async fn test_dict_primitive_values_bp_codes() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict_values: Vec = vec![100, 200, 300, 400]; let dict_size = dict_values.len(); let len = 3000; @@ -1033,7 +1036,7 @@ mod tests { #[crate::test] async fn test_dict_mixed_width_u8_codes_u32_values() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict_values: Vec = vec![100, 200, 300, 400]; let len = 3000; let codes: Vec = (0..len).map(|i| (i % dict_values.len()) as u8).collect(); @@ -1068,7 +1071,7 @@ mod tests { #[crate::test] async fn test_dict_mixed_width_u16_codes_u32_values() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let dict_values: Vec = vec![1000, 2000, 3000, 4000, 5000]; let len = 2048; let codes: Vec = (0..len).map(|i| (i % dict_values.len()) as u16).collect(); @@ -1103,7 +1106,7 @@ mod tests { #[crate::test] async fn test_runend_mixed_width_u64_ends_u32_values() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let ends: Vec = vec![1000, 2000, 3000]; let values: Vec = vec![10, 20, 30]; let len = 3000; @@ -1208,7 +1211,7 @@ mod tests { #[case] slice_start: usize, #[case] slice_end: usize, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bit_width = 10u8; let max_val = (1u32 << bit_width) - 1; let len = 5000; @@ -1310,7 +1313,7 @@ mod tests { #[case] slice_start: usize, #[case] slice_end: usize, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bit_width = 10u8; let max_val = (1u32 << bit_width) - 1; let len = 5000; @@ -1356,7 +1359,7 @@ mod tests { #[case] slice_start: usize, #[case] slice_end: usize, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let reference = 100u32; let bit_width = 10u8; let max_val = (1u32 << bit_width) - 1; @@ -1406,7 +1409,7 @@ mod tests { #[case] slice_start: usize, #[case] slice_end: usize, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict_reference = 1_000_000u32; let dict_residuals: Vec = (0..64).collect(); let dict_expected: Vec = dict_residuals.iter().map(|&r| r + dict_reference).collect(); @@ -1512,7 +1515,7 @@ mod tests { #[crate::test] async fn test_for_bitpacked_u8() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 4; let len = 3000; let reference = 100u8; @@ -1545,7 +1548,7 @@ mod tests { #[crate::test] async fn test_for_bitpacked_u16() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 10; let len = 3000; let reference = 1000u16; @@ -1580,7 +1583,7 @@ mod tests { #[crate::test] async fn test_for_bitpacked_u64() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 20; let len = 3000; let reference = 100_000u64; @@ -1630,7 +1633,7 @@ mod tests { #[crate::test] async fn test_single_element() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let values: Vec = vec![42]; let primitive = PrimitiveArray::new(Buffer::from(values.clone()), NonNullable); let bp = @@ -1654,7 +1657,7 @@ mod tests { #[crate::test] async fn test_exactly_elements_per_block() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Exactly 2048 elements — one full block, no remainder let bit_width: u8 = 6; let len = 2048; @@ -1691,7 +1694,7 @@ mod tests { #[test] fn test_has_standalone_kernel_true_cases() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // BitPacked — leaf encoding, no children. let bp = bitpacked_array_u32(6, 2048, &mut ctx); let bp_arr = bp.into_array(); @@ -1743,7 +1746,7 @@ mod tests { /// a kernel registered in the CUDA session. #[crate::test] fn test_has_standalone_kernel_implies_registered_kernel() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let session = CudaSession::create_execution_ctx(&cuda_session())?; let cuda_session = session.cuda_session(); @@ -1810,7 +1813,7 @@ mod tests { #[crate::test] async fn test_alp_f64_for_bitpacked() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // ALP(FoR(BitPacked)) with f64: same structure as the f32 test. let len = 3000; let exponents = Exponents { e: 2, f: 0 }; @@ -1854,7 +1857,7 @@ mod tests { #[case] len: usize, #[case] slice_range: Option>, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut values: Vec = (0..len).map(|i| (i as f64) * 1.1).collect(); // Insert exception values that ALP can't encode. values[0] = 99.9; @@ -1904,7 +1907,7 @@ mod tests { #[crate::test] async fn alp_slice_device_patches() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); // Regression test for https://github.com/vortex-data/vortex/issues/7838#issuecomment-4452796116. let mut cuda_ctx = CudaSession::create_execution_ctx(&cuda_session())?; let len = 4096; @@ -1969,7 +1972,7 @@ mod tests { #[crate::test] async fn test_runend_u32_ends_u16_values() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); // RunEnd with u32 ends, u16 values. Output type = u16. // Ends (u32) differ from output (u16) → pending subtree. let ends: Vec = vec![500, 1000, 1500, 2000]; @@ -2016,7 +2019,7 @@ mod tests { #[crate::test] async fn test_dict_bitpacked_u8_codes_u32_values() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); // Dict with BitPacked u8 codes (narrower than u32 output) and u32 values. // The kernel's bitunpack_typed decodes at the source's native width and // widens to T, so this fuses into a single kernel launch. @@ -2066,7 +2069,7 @@ mod tests { #[case] len: usize, #[case] dict_values: Vec, ) -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let dict_size = dict_values.len(); let codes: Vec = (0..len).map(|i| (i % dict_size) as u8).collect(); @@ -2114,7 +2117,7 @@ mod tests { #[case] len: usize, #[case] dict_values: Vec, ) -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let dict_size = dict_values.len(); let codes: Vec = (0..len).map(|i| (i % dict_size) as u8).collect(); @@ -2175,7 +2178,7 @@ mod tests { #[case] ends: Vec, #[case] values: Vec, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ends_u64: Vec = ends.iter().map(|e| (*e).into()).collect(); let len = *ends_u64.last().unwrap() as usize; let bit_width = 64 - ends_u64.iter().max().unwrap().leading_zeros() as u8; @@ -2217,7 +2220,7 @@ mod tests { /// at native width and widens to T, fusing everything. #[crate::test] async fn test_runend_mixed_width_for_bp_u16_ends_u32_values() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ends: Vec = vec![500, 1000, 1500, 2000]; let values: Vec = vec![100, 200, 300, 400]; let len = 2000usize; @@ -2257,7 +2260,7 @@ mod tests { #[crate::test] async fn test_sliced_dict_mixed_width() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Sliced Dict with u8 codes and u32 values — combines PartiallyFused + slice handling. let dict_values: Vec = vec![100, 200, 300, 400]; let full_len = 4096; @@ -2370,7 +2373,7 @@ mod tests { /// Nullable Primitive array — LOAD source with validity propagated. #[crate::test] async fn test_nullable_primitive() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&cuda_session())?; let array = PrimitiveArray::from_option_iter( @@ -2393,7 +2396,7 @@ mod tests { /// validity, so this produces a real nullable FoR(BitPacked) tree. #[crate::test] async fn test_nullable_for_bitpacked() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&cuda_session())?; let len = 2048; @@ -2465,7 +2468,7 @@ mod tests { /// AllValid nullable array — should fuse and produce AllValid output. #[crate::test] async fn test_all_valid_nullable() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&cuda_session())?; let values: Vec = (0..2048).collect(); @@ -2501,7 +2504,7 @@ mod tests { /// Dict with non-nullable codes but nullable values should still fuse. #[crate::test] async fn test_dict_nullable_values_fuses() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&cuda_session())?; let codes = PrimitiveArray::new(buffer![0u32, 1, 2, 2, 1, 0], NonNullable); @@ -2528,7 +2531,7 @@ mod tests { #[case::for_bitpacked(true)] #[crate::test] async fn test_nullable_fused_then_filter(#[case] compressed: bool) -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&cuda_session())?; let len = 2048usize; @@ -2590,7 +2593,7 @@ mod tests { #[crate::test] async fn test_bitpacked_with_patches() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let len = 3000; let bit_width: u8 = 4; let max_val = (1u32 << bit_width) - 1; @@ -2631,7 +2634,7 @@ mod tests { #[case] len: usize, #[case] slice_range: Option>, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 4; let max_val = (1u32 << bit_width) - 1; let values: Vec = (0..len) @@ -2669,7 +2672,7 @@ mod tests { #[crate::test] async fn test_for_bitpacked_with_patches() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let len = 3000; let bit_width: u8 = 6; let reference = 42u32; @@ -2706,7 +2709,7 @@ mod tests { #[crate::test] async fn test_for_bitpacked_with_patches_sliced() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let len = 5000; let bit_width: u8 = 6; let reference = 42u32; @@ -2752,7 +2755,7 @@ mod tests { #[case] len: usize, #[case] slice_range: Option>, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut values: Vec = (0..len).map(|i| (i as f32) * 1.1).collect(); // Insert exception values that ALP can't encode. values[0] = 99.9; @@ -2805,7 +2808,7 @@ mod tests { /// u8 BitPacked with patches (bit_width=3, patch values > 7). #[crate::test] async fn test_bitpacked_with_patches_u8() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 3; let len = 3000usize; let max_val = (1u8 << bit_width) - 1; @@ -2837,7 +2840,7 @@ mod tests { /// u16 BitPacked with patches (bit_width=6, patch values > 63). #[crate::test] async fn test_bitpacked_with_patches_u16() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 6; let len = 3000usize; let max_val = (1u16 << bit_width) - 1; @@ -2869,7 +2872,7 @@ mod tests { /// u64 BitPacked with patches (bit_width=4, patch values > 15). #[crate::test] async fn test_bitpacked_with_patches_u64() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 4; let len = 3000usize; let max_val = (1u64 << bit_width) - 1; @@ -2901,7 +2904,7 @@ mod tests { /// Dict where codes are BitPacked u32 with patches exceeding the bit width. #[crate::test] async fn test_dict_bitpacked_codes_with_patches() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dict_values: Vec = (0..256).map(|i| i * 1000 + 42).collect(); let len = 3000; let bit_width: u8 = 4; @@ -2936,7 +2939,7 @@ mod tests { /// Patches placed exactly at FastLanes chunk boundaries (1024-element chunks). #[crate::test] async fn test_bitpacked_patches_at_chunk_boundaries() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let len = 4096usize; let bit_width: u8 = 4; let max_val = (1u32 << bit_width) - 1; @@ -2962,7 +2965,7 @@ mod tests { /// Large array (100k elements) spanning many blocks with sparse patches. #[crate::test] async fn test_bitpacked_large_array_with_patches() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let len = 100_000usize; let bit_width: u8 = 6; let max_val = (1u32 << bit_width) - 1; @@ -2992,7 +2995,7 @@ mod tests { /// dispatch alongside patch application. #[crate::test] async fn test_nullable_bitpacked_with_patches() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&cuda_session())?; let len = 3000usize; @@ -3030,7 +3033,7 @@ mod tests { /// Extreme case: ALL values are patches (bit_width=1, every value > 1). #[crate::test] async fn test_bitpacked_all_patches() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bit_width: u8 = 1; let len = 2000usize; // All values >= 2, so every single element exceeds max storable (1) and diff --git a/vortex-cuda/src/hybrid_dispatch/mod.rs b/vortex-cuda/src/hybrid_dispatch/mod.rs index a4ce90f55b8..20dfa3101ef 100644 --- a/vortex-cuda/src/hybrid_dispatch/mod.rs +++ b/vortex-cuda/src/hybrid_dispatch/mod.rs @@ -151,6 +151,8 @@ pub async fn try_gpu_dispatch( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::ArrayRef; use vortex::array::IntoArray; @@ -171,15 +173,17 @@ mod tests { use vortex::error::VortexResult; use vortex::mask::Mask; use vortex::scalar::Scalar; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use crate::CanonicalCudaExt; use crate::executor::CudaArrayExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn for_bp>(values: Vec, reference: T) -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bp = BitPacked::encode( &PrimitiveArray::new(Buffer::from(values), NonNullable).into_array(), 7, @@ -194,7 +198,7 @@ mod tests { /// FoR(BitPacked) u32 — entire tree compiles into a single fused plan. #[crate::test] async fn test_fused() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let mut ctx = CudaSession::create_execution_ctx(&crate::cuda_session()).vortex_expect("ctx"); let values: Vec = (0..2048).map(|i| (i % 128) as u32).collect(); @@ -222,7 +226,7 @@ mod tests { /// Exercises the unsigned type reinterpretation in CudaDispatchPlan::execute. #[crate::test] async fn test_fused_f32() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); use vortex::encodings::alp::ALP; use vortex::encodings::alp::Exponents; @@ -258,7 +262,7 @@ mod tests { /// ALP with patches retains exception values through automatic GPU dispatch. #[crate::test] async fn test_alp_patches_auto_dispatch() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); use vortex::array::patches::Patches; use vortex::array::validity::Validity::NonNullable as NN; use vortex::buffer::buffer; @@ -300,7 +304,7 @@ mod tests { /// 3 launches: nvcomp + fused FoR+BP + fused LOAD+FoR+BP+DICT. #[crate::test] async fn test_partial_fusion() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); use vortex::array::arrays::DictArray; use vortex::array::session::ArraySessionExt; use vortex::encodings::fastlanes; @@ -364,7 +368,7 @@ mod tests { /// Filter(FoR(BP), mask) — FoR+BP fuses via dyn dispatch, then CUB filters the result. #[crate::test] async fn test_filter_fused_child() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let mut ctx = CudaSession::create_execution_ctx(&crate::cuda_session()).vortex_expect("ctx"); @@ -408,7 +412,7 @@ mod tests { ))] #[crate::test] async fn test_ext_storage_gpu_decode(#[case] ext: ExtensionArray) -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let mut ctx = CudaSession::create_execution_ctx(&crate::cuda_session()).vortex_expect("ctx"); @@ -432,7 +436,7 @@ mod tests { /// Extension over already-canonical storage executes unchanged. #[crate::test] async fn test_ext_canonical_storage() -> VortexResult<()> { - let mut cpu_ctx = array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let mut ctx = CudaSession::create_execution_ctx(&crate::cuda_session()).vortex_expect("ctx"); diff --git a/vortex-cuda/src/kernel/arrays/constant.rs b/vortex-cuda/src/kernel/arrays/constant.rs index c777991ffd7..0fbad72493e 100644 --- a/vortex-cuda/src/kernel/arrays/constant.rs +++ b/vortex-cuda/src/kernel/arrays/constant.rs @@ -189,6 +189,8 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::IntoArray; use vortex::array::arrays::ConstantArray; @@ -197,12 +199,15 @@ mod tests { use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::scalar::Scalar; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; use crate::CanonicalCudaExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn make_constant_array>(value: T, len: usize) -> ConstantArray { ConstantArray::new(value, len) } @@ -241,7 +246,7 @@ mod tests { #[case] constant_array: ConstantArray, #[case] expected: PrimitiveArray, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -260,7 +265,7 @@ mod tests { #[crate::test] async fn test_cuda_constant_empty_array() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -280,7 +285,7 @@ mod tests { #[crate::test] async fn test_cuda_constant_small_array() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/arrays/dict.rs b/vortex-cuda/src/kernel/arrays/dict.rs index c490348c6b0..e9bb20daa94 100644 --- a/vortex-cuda/src/kernel/arrays/dict.rs +++ b/vortex-cuda/src/kernel/arrays/dict.rs @@ -373,6 +373,8 @@ async fn execute_dict_varbinview( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex::array::ExecutionCtx; use vortex::array::IntoArray; use vortex::array::arrays::BoolArray; @@ -386,6 +388,7 @@ mod tests { use vortex::dtype::DecimalDType; use vortex::dtype::i256; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; @@ -395,6 +398,8 @@ mod tests { use crate::device_buffer::cuda_backing_allocation; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Copy a CUDA primitive array result to host memory. fn cuda_primitive_to_host(prim: PrimitiveArray) -> VortexResult { Ok(PrimitiveArray::from_byte_buffer( @@ -406,7 +411,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_bool_gathers_packed_validity_bits() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -468,7 +473,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_u32_values_u8_codes() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -498,7 +503,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_u64_values_u16_codes() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -531,7 +536,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_i32_values_u32_codes() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -560,7 +565,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_large_array() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -590,7 +595,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_values_with_validity() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -620,7 +625,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_codes_with_validity() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -655,7 +660,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_both_with_validity() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -697,7 +702,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_i64_values_with_validity() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -740,7 +745,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_all_valid_matches_baseline() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -781,7 +786,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_decimal_i8_values() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -808,7 +813,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_decimal_i16_values() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -835,7 +840,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_decimal_i32_values() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -862,7 +867,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_decimal_i64_values() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -892,7 +897,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_decimal_i128_values() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -938,7 +943,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_string_values_u8_codes() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -962,7 +967,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_string_values_u16_codes() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -986,7 +991,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_string_max_inlined_12_bytes() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -1012,7 +1017,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_string_outlined_views() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -1041,7 +1046,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_string_empty_strings() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -1065,7 +1070,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_string_values_with_validity() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -1090,7 +1095,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_string_outlined_with_validity() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -1122,7 +1127,7 @@ mod tests { #[crate::test] async fn test_cuda_dict_decimal_i256_values() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/arrays/list.rs b/vortex-cuda/src/kernel/arrays/list.rs index 0143aac5cde..167c12df9c4 100644 --- a/vortex-cuda/src/kernel/arrays/list.rs +++ b/vortex-cuda/src/kernel/arrays/list.rs @@ -141,6 +141,8 @@ async fn list_views_typed( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::arrays::BoolArray; use vortex::array::arrays::ListArray; @@ -148,18 +150,21 @@ mod tests { use vortex::buffer::Buffer; use vortex::buffer::buffer; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; use crate::CanonicalCudaExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::single_run(vec![0i32, 2, 5, 9])] #[case::empty_lists(vec![0i32, 0, 3, 3])] #[crate::test] async fn test_cuda_list_decompression(#[case] offsets: Vec) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -193,7 +198,7 @@ mod tests { #[crate::test] async fn test_cuda_list_with_nulls() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/arrays/masked.rs b/vortex-cuda/src/kernel/arrays/masked.rs index 652b788c7df..c318f7a8af9 100644 --- a/vortex-cuda/src/kernel/arrays/masked.rs +++ b/vortex-cuda/src/kernel/arrays/masked.rs @@ -59,6 +59,8 @@ impl CudaExecute for MaskedExecutor { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex::array::IntoArray; use vortex::array::arrays::BoolArray; use vortex::array::arrays::MaskedArray; @@ -66,15 +68,18 @@ mod tests { use vortex::array::assert_arrays_eq; use vortex::buffer::buffer; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; use crate::CanonicalCudaExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[crate::test] async fn test_cuda_masked_applies_validity() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/encodings/alp.rs b/vortex-cuda/src/kernel/encodings/alp.rs index abe138ce4ba..e543db1aca0 100644 --- a/vortex-cuda/src/kernel/encodings/alp.rs +++ b/vortex-cuda/src/kernel/encodings/alp.rs @@ -138,10 +138,10 @@ where mod tests { use std::f32; use std::f64; + use std::sync::LazyLock; use rstest::rstest; use vortex::array::IntoArray; - use vortex::array::array_session; use vortex::array::arrays::PrimitiveArray; use vortex::array::assert_arrays_eq; use vortex::array::patches::Patches; @@ -152,6 +152,7 @@ mod tests { use vortex::encodings::alp::Exponents; use vortex::encodings::alp::alp_encode; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; @@ -160,6 +161,8 @@ mod tests { use crate::executor::CudaArrayExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Irrational values ALP cannot encode losslessly, guaranteed to land /// in the exception list on round-trip through `alp_encode`. const UNENCODABLE: f64 = f64::consts::PI; @@ -170,7 +173,7 @@ mod tests { /// Patches must carry `chunk_offsets` — the fused kernel requires them. #[crate::test] async fn test_cuda_alp_decompression_f32() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -226,7 +229,7 @@ mod tests { async fn test_cuda_alp_nullable_with_patches( #[case] mode: CudaDispatchMode, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context") .with_dispatch_mode(mode); @@ -245,11 +248,7 @@ mod tests { Some(5.0), ]; let prim = PrimitiveArray::from_option_iter(values); - let alp_array = alp_encode( - prim.as_view(), - None, - &mut array_session().create_execution_ctx(), - )?; + let alp_array = alp_encode(prim.as_view(), None, &mut SESSION.create_execution_ctx())?; let gpu_result = alp_array .clone() @@ -271,7 +270,7 @@ mod tests { #[case::standalone(CudaDispatchMode::StandaloneOnly)] #[crate::test] async fn test_cuda_alp_all_valid_nullable(#[case] mode: CudaDispatchMode) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context") .with_dispatch_mode(mode); @@ -280,11 +279,7 @@ mod tests { Buffer::from(vec![1.0f32, 2.0, 3.0, 4.0, 5.0]), Validity::AllValid, ); - let alp_array = alp_encode( - values.as_view(), - None, - &mut array_session().create_execution_ctx(), - )?; + let alp_array = alp_encode(values.as_view(), None, &mut SESSION.create_execution_ctx())?; let gpu_result = alp_array .clone() @@ -310,7 +305,7 @@ mod tests { async fn test_cuda_alp_multi_chunk_sparse_patches( #[case] mode: CudaDispatchMode, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context") .with_dispatch_mode(mode); @@ -328,11 +323,7 @@ mod tests { }) .collect(); let prim = PrimitiveArray::new(values, Validity::NonNullable); - let alp_array = alp_encode( - prim.as_view(), - None, - &mut array_session().create_execution_ctx(), - )?; + let alp_array = alp_encode(prim.as_view(), None, &mut SESSION.create_execution_ctx())?; assert!( alp_array.patches().is_some(), "expected patches from ALP exceptions" @@ -361,7 +352,7 @@ mod tests { async fn test_cuda_alp_f64_multi_chunk_with_patches( #[case] mode: CudaDispatchMode, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context") .with_dispatch_mode(mode); @@ -377,11 +368,7 @@ mod tests { }) .collect(); let prim = PrimitiveArray::new(values, Validity::NonNullable); - let alp_array = alp_encode( - prim.as_view(), - None, - &mut array_session().create_execution_ctx(), - )?; + let alp_array = alp_encode(prim.as_view(), None, &mut SESSION.create_execution_ctx())?; assert!( alp_array.patches().is_some(), "expected patches from ALP exceptions" @@ -406,7 +393,7 @@ mod tests { /// (existing tests have ≤ 6 patches per chunk). #[crate::test] async fn test_cuda_alp_dense_patches_single_chunk() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -464,7 +451,7 @@ mod tests { #[case::standalone(CudaDispatchMode::StandaloneOnly)] #[crate::test] async fn test_cuda_alp_partial_tail_chunk(#[case] mode: CudaDispatchMode) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context") .with_dispatch_mode(mode); @@ -473,11 +460,7 @@ mod tests { .map(|i| if i == 1400 { UNENCODABLE } else { i as f64 }) .collect(); let prim = PrimitiveArray::new(values, Validity::NonNullable); - let alp_array = alp_encode( - prim.as_view(), - None, - &mut array_session().create_execution_ctx(), - )?; + let alp_array = alp_encode(prim.as_view(), None, &mut SESSION.create_execution_ctx())?; assert!( alp_array.patches().is_some(), "expected patches from ALP exceptions" diff --git a/vortex-cuda/src/kernel/encodings/bitpacked.rs b/vortex-cuda/src/kernel/encodings/bitpacked.rs index 88cb68b5048..3b28692722c 100644 --- a/vortex-cuda/src/kernel/encodings/bitpacked.rs +++ b/vortex-cuda/src/kernel/encodings/bitpacked.rs @@ -237,6 +237,8 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use futures::executor::block_on; use rstest::rstest; use vortex::array::IntoArray; @@ -248,12 +250,15 @@ mod tests { use vortex::buffer::buffer; use vortex::encodings::fastlanes::BitPackedArrayExt; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; use crate::CanonicalCudaExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::u8((0u8..128u8).cycle().take(2048), 6)] #[case::u16((0u16..128u16).cycle().take(2048), 6)] @@ -264,7 +269,7 @@ mod tests { #[case] iter: impl Iterator, #[case] bw: u8, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -291,7 +296,7 @@ mod tests { #[crate::test] fn test_patches() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -329,7 +334,7 @@ mod tests { #[case::bw_7(7)] #[crate::test] fn test_cuda_bitunpack_u8(#[case] bit_width: u8) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -377,7 +382,7 @@ mod tests { #[case::bw_15(15)] #[crate::test] fn test_cuda_bitunpack_u16(#[case] bit_width: u8) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -441,7 +446,7 @@ mod tests { #[case::bw_31(31)] #[crate::test] fn test_cuda_bitunpack_u32(#[case] bit_width: u8) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -537,7 +542,7 @@ mod tests { #[case::bw_63(63)] #[crate::test] fn test_cuda_bitunpack_u64(#[case] bit_width: u8) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -575,7 +580,7 @@ mod tests { #[case] slice_start: usize, #[case] slice_end: usize, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let bit_width = 32; let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -619,7 +624,7 @@ mod tests { #[case] expected_offset: u16, #[case] expected_packed_len: usize, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = PrimitiveArray::new( (0u16..4096) .map(|i| if i % 1000 == 0 { 600 } else { i % 512 }) @@ -651,7 +656,7 @@ mod tests { /// offset_within_chunk. #[crate::test] fn test_cuda_bitunpack_sliced_patches_offset_within_chunk() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -687,7 +692,7 @@ mod tests { /// Test slicing a bitpacked array multiple times, accumulating offset_within_chunk. #[crate::test] fn test_cuda_bitunpack_double_sliced_patches() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -735,7 +740,7 @@ mod tests { /// Test slicing to skip an entire chunk's worth of patches. #[crate::test] fn test_cuda_bitunpack_sliced_skip_first_chunk_patches() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/encodings/date_time_parts.rs b/vortex-cuda/src/kernel/encodings/date_time_parts.rs index 025bf7f2d74..9a1a339aa67 100644 --- a/vortex-cuda/src/kernel/encodings/date_time_parts.rs +++ b/vortex-cuda/src/kernel/encodings/date_time_parts.rs @@ -200,6 +200,8 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::IntoArray; use vortex::array::arrays::PrimitiveArray; @@ -213,12 +215,15 @@ mod tests { use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::extension::datetime::TimeUnit; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; use crate::CanonicalCudaExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn make_datetimeparts_array( days: Vec, seconds: Vec, @@ -279,7 +284,7 @@ mod tests { #[case] subseconds: Vec, #[case] time_unit: TimeUnit, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -302,7 +307,7 @@ mod tests { /// entirely unsigned components, which is what panicked on `taxi`. #[crate::test] async fn test_cuda_datetimeparts_unsigned_components() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -343,7 +348,7 @@ mod tests { /// seconds, which is only decoded correctly if each component keeps its own signedness. #[crate::test] async fn test_cuda_datetimeparts_mixed_signedness() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -381,7 +386,7 @@ mod tests { #[crate::test] async fn test_cuda_datetimeparts_large_array() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -406,7 +411,7 @@ mod tests { #[crate::test] async fn test_cuda_datetimeparts_with_nulls() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/encodings/decimal_byte_parts.rs b/vortex-cuda/src/kernel/encodings/decimal_byte_parts.rs index a54df06fb4c..ee3814ca9fc 100644 --- a/vortex-cuda/src/kernel/encodings/decimal_byte_parts.rs +++ b/vortex-cuda/src/kernel/encodings/decimal_byte_parts.rs @@ -68,6 +68,8 @@ impl CudaExecute for DecimalBytePartsExecutor { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::IntoArray; use vortex::array::arrays::PrimitiveArray; @@ -77,11 +79,14 @@ mod tests { use vortex::dtype::DecimalDType; use vortex::encodings::decimal_byte_parts::DecimalByteParts; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::i8_p5_s2(Buffer::from(vec![100i8, 101, 102, -1, -100]), 5, 2)] #[case::i16_p10_s2(Buffer::from(vec![100i16, 200, 300, 400, 500]), 10, 2)] @@ -93,7 +98,7 @@ mod tests { #[case] precision: u8, #[case] scale: i8, ) { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("create execution context"); diff --git a/vortex-cuda/src/kernel/encodings/delta.rs b/vortex-cuda/src/kernel/encodings/delta.rs index 1ae3781eeee..0d01b3789c9 100644 --- a/vortex-cuda/src/kernel/encodings/delta.rs +++ b/vortex-cuda/src/kernel/encodings/delta.rs @@ -157,24 +157,29 @@ async fn decode_delta(array: DeltaArray, ctx: &mut CudaExecutionCtx) -> VortexRe #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::IntoArray; use vortex::array::assert_arrays_eq; use vortex::array::validity::Validity; use vortex::buffer::Buffer; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; use crate::CanonicalCudaExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Decodes on the GPU and compares against the independent uncompressed fixture. async fn assert_gpu_matches_expected( delta: DeltaArray, expected: ArrayRef, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -196,7 +201,7 @@ mod tests { /// spans several chunks. #[crate::test] async fn test_cuda_delta_u8() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let primitive = PrimitiveArray::new( Buffer::from_iter((0u8..=255).cycle().take(3000)), Validity::NonNullable, @@ -208,7 +213,7 @@ mod tests { #[crate::test] async fn test_cuda_delta_u16() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let primitive = PrimitiveArray::new(Buffer::from_iter(0u16..3000), Validity::NonNullable); let delta = Delta::try_from_primitive_array(&primitive, &mut ctx)?; @@ -217,7 +222,7 @@ mod tests { #[crate::test] async fn test_cuda_delta_u32() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let primitive = PrimitiveArray::new( Buffer::from_iter((0u32..3000).map(|i| i * 7)), Validity::NonNullable, @@ -229,7 +234,7 @@ mod tests { #[crate::test] async fn test_cuda_delta_u64() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let primitive = PrimitiveArray::new( Buffer::from_iter((0u64..3000).map(|i| i * 1_000_003)), Validity::NonNullable, @@ -243,7 +248,7 @@ mod tests { /// through the unsigned kernel unchanged. #[crate::test] async fn test_cuda_delta_signed_values() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let primitive = PrimitiveArray::new( Buffer::from_iter((0..3000i32).map(|i| i - 1500)), Validity::NonNullable, @@ -260,7 +265,7 @@ mod tests { #[case::across_chunks(1000, 1500)] #[crate::test] async fn test_cuda_delta_sliced(#[case] start: usize, #[case] end: usize) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let primitive = PrimitiveArray::new( Buffer::from_iter((0..3000u32).map(|i| i * 3)), Validity::NonNullable, @@ -279,7 +284,7 @@ mod tests { /// Nulls ride alongside the values, and the validity is narrowed to the logical slice. #[crate::test] async fn test_cuda_delta_nullable() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let primitive = PrimitiveArray::from_option_iter( (0..3000u32).map(|value| (value % 7 != 0).then_some(value)), ); diff --git a/vortex-cuda/src/kernel/encodings/for_.rs b/vortex-cuda/src/kernel/encodings/for_.rs index af64b026182..bcec39213a2 100644 --- a/vortex-cuda/src/kernel/encodings/for_.rs +++ b/vortex-cuda/src/kernel/encodings/for_.rs @@ -165,6 +165,8 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::IntoArray; use vortex::array::arrays::PrimitiveArray; @@ -178,13 +180,15 @@ mod tests { use vortex::encodings::fastlanes::FoRArray; use vortex::error::VortexExpect; use vortex::scalar::Scalar; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use super::*; use crate::CanonicalCudaExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn make_for_array>(input_data: Vec, reference: T) -> FoRArray { FoR::try_new( PrimitiveArray::new(Buffer::from(input_data), NonNullable).into_array(), @@ -200,7 +204,7 @@ mod tests { #[case::u64(make_for_array((0..2050).map(|i| (i % 2050) as u64).collect(), 1000000u64))] #[crate::test] async fn test_cuda_for_decompression(#[case] for_array: FoRArray) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -219,7 +223,7 @@ mod tests { #[crate::test] async fn test_signed_ffor() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -228,7 +232,7 @@ mod tests { .take(1024) .collect::>() .into_array(); - let packed = BitPacked::encode(&values, 3, &mut array_session().create_execution_ctx()) + let packed = BitPacked::encode(&values, 3, &mut SESSION.create_execution_ctx()) .unwrap() .into_array(); let for_array = FoR::try_new(packed, (-8i8).into()).unwrap(); @@ -258,7 +262,7 @@ mod tests { where T: NativePType + Into + From, { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -271,7 +275,7 @@ mod tests { } let values = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array(); - let packed = BitPacked::encode(&values, 8, &mut array_session().create_execution_ctx())?; + let packed = BitPacked::encode(&values, 8, &mut SESSION.create_execution_ctx())?; assert!( packed.patches().is_some(), "test setup expects the exceptions to be stored as patches" diff --git a/vortex-cuda/src/kernel/encodings/fsst.rs b/vortex-cuda/src/kernel/encodings/fsst.rs index 26f2d059a9a..efa499b60ec 100644 --- a/vortex-cuda/src/kernel/encodings/fsst.rs +++ b/vortex-cuda/src/kernel/encodings/fsst.rs @@ -398,6 +398,8 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use arrow_schema::DataType; use arrow_schema::Field; use rstest::rstest; @@ -410,6 +412,7 @@ mod tests { use vortex::encodings::fsst::fsst_compress; use vortex::encodings::fsst::fsst_train_compressor; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; @@ -420,8 +423,10 @@ mod tests { use crate::session::CudaSession; use crate::session::VarBinExportLayout; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn cuda_ctx_with_varbin_layout(layout: VarBinExportLayout) -> VortexResult { - let session = vortex::array::array_session() + let session = VortexSession::empty() .with_some(CudaSession::try_default()?.with_varbin_export_layout(layout)); CudaSession::create_execution_ctx(&session) } @@ -476,7 +481,7 @@ mod tests { #[case] strings: Vec>, #[case] dtype: DType, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -503,7 +508,7 @@ mod tests { /// Verifies that the view kernel applies a sliced validity bitmap's nonzero bit offset. #[crate::test] async fn test_cuda_fsst_decompression_sliced_validity() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); let values = [ @@ -622,7 +627,7 @@ mod tests { /// Exercises the multi-block grid-stride path on a larger dataset. #[crate::test] async fn test_cuda_fsst_decompression_roundtrip_large() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); use vortex_fsst::test_utils::make_fsst_clickbench_urls; let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) diff --git a/vortex-cuda/src/kernel/encodings/onpair.rs b/vortex-cuda/src/kernel/encodings/onpair.rs index 306aa04b1c9..a97aca0941b 100644 --- a/vortex-cuda/src/kernel/encodings/onpair.rs +++ b/vortex-cuda/src/kernel/encodings/onpair.rs @@ -662,6 +662,8 @@ fn sum_lengths(lengths: &PrimitiveArray) -> VortexResult { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use arrow_schema::DataType; use arrow_schema::Field; use rstest::rstest; @@ -671,6 +673,7 @@ mod tests { use vortex::buffer::Buffer; use vortex::dtype::Nullability; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use vortex_onpair::DEFAULT_CONFIG; use vortex_onpair::onpair_compress; @@ -684,8 +687,10 @@ mod tests { use crate::session::CudaSession; use crate::session::VarBinExportLayout; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn cuda_ctx_with_varbin_layout(layout: VarBinExportLayout) -> VortexResult { - let session = vortex::array::array_session() + let session = VortexSession::empty() .with_some(CudaSession::try_default()?.with_varbin_export_layout(layout)); CudaSession::create_execution_ctx(&session) } @@ -751,7 +756,7 @@ mod tests { #[case] strings: Vec>, #[case] dtype: DType, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -777,7 +782,7 @@ mod tests { /// which is what panicked with "expected host buffer" on `taxi` and TPC-H `l_comment`. #[crate::test] async fn test_cuda_onpair_device_resident_dictionary() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -825,7 +830,7 @@ mod tests { /// so this exercises the nonzero `code_start` window. #[crate::test] async fn test_cuda_onpair_decompression_sliced() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); let values = vec![ @@ -854,7 +859,7 @@ mod tests { /// empty-views path. #[crate::test] async fn test_cuda_onpair_decompression_null_slice() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); let values = vec![Some(&b"alpha"[..]), None, None, Some(&b"omega"[..])]; @@ -876,7 +881,7 @@ mod tests { /// Exercises many 128-token batches and the multi-block decode grid. #[crate::test] async fn test_cuda_onpair_decompression_roundtrip_large() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -910,7 +915,7 @@ mod tests { /// exact-sized decoded window allocation. #[crate::test] async fn test_cuda_onpair_decompression_sliced_large() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -950,7 +955,7 @@ mod tests { /// exactly the byte `b` and every row is coded byte per byte. #[crate::test] async fn test_cuda_onpair_decompression_u8_codes() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/encodings/runend.rs b/vortex-cuda/src/kernel/encodings/runend.rs index 9cf0380923e..5519e3de79c 100644 --- a/vortex-cuda/src/kernel/encodings/runend.rs +++ b/vortex-cuda/src/kernel/encodings/runend.rs @@ -201,6 +201,8 @@ async fn decode_runend_typed = LazyLock::new(VortexSession::empty); + fn make_runend_array(ends: Vec, values: Vec, ctx: &mut ExecutionCtx) -> RunEndArray where V: NativePType, @@ -245,7 +250,7 @@ mod tests { #[case::u64_ends_i32_values(|ctx: &mut ExecutionCtx| make_runend_array(vec![2u64, 5, 10], vec![1i32, 2, 3], ctx))] #[crate::test] async fn test_cuda_runend_types(#[case] build: RunEndBuilder) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -265,7 +270,7 @@ mod tests { #[crate::test] async fn test_cuda_runend_large_array() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -294,7 +299,7 @@ mod tests { #[crate::test] async fn test_cuda_runend_single_run() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -315,7 +320,7 @@ mod tests { #[crate::test] async fn test_cuda_runend_many_small_runs() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -341,7 +346,7 @@ mod tests { #[crate::test] async fn test_cuda_runend_nullable_values() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -375,7 +380,7 @@ mod tests { /// straddle output byte boundaries. #[crate::test] async fn test_cuda_runend_nullable_values_across_byte_boundaries() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/encodings/sequence.rs b/vortex-cuda/src/kernel/encodings/sequence.rs index 32adcb9cb48..86bf56107d4 100644 --- a/vortex-cuda/src/kernel/encodings/sequence.rs +++ b/vortex-cuda/src/kernel/encodings/sequence.rs @@ -94,6 +94,8 @@ async fn execute_typed( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use futures::executor::block_on; use rstest::rstest; use vortex::array::IntoArray; @@ -107,6 +109,7 @@ mod tests { use vortex::encodings::sequence::Sequence; use vortex::error::VortexResult; use vortex::scalar::PValue; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use crate::CanonicalCudaExt; @@ -114,6 +117,8 @@ mod tests { use crate::executor::CudaExecute; use crate::kernel::encodings::sequence::SequenceExecutor; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::u8(10u8, 2u8, 10)] #[case::u16(10u16, 2u16, 100)] @@ -140,7 +145,7 @@ mod tests { len: usize, nullability: Nullability, ) { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()).unwrap(); let array = Sequence::try_new_typed(base, multiplier, nullability, len) @@ -161,7 +166,7 @@ mod tests { #[crate::test] async fn test_sequence_arithmetic_ptype_differs_from_output() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()).unwrap(); let array = Sequence::try_new_typed(100i32, -10i32, Nullability::NonNullable, 5)? diff --git a/vortex-cuda/src/kernel/encodings/zigzag.rs b/vortex-cuda/src/kernel/encodings/zigzag.rs index f7978a2a748..33b22bdc29f 100644 --- a/vortex-cuda/src/kernel/encodings/zigzag.rs +++ b/vortex-cuda/src/kernel/encodings/zigzag.rs @@ -125,6 +125,8 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex::array::IntoArray; use vortex::array::arrays::PrimitiveArray; use vortex::array::assert_arrays_eq; @@ -132,15 +134,18 @@ mod tests { use vortex::buffer::Buffer; use vortex::encodings::zigzag::ZigZag; use vortex::error::VortexExpect; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; use crate::CanonicalCudaExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[crate::test] async fn test_cuda_zigzag_decompression_u32() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/encodings/zstd.rs b/vortex-cuda/src/kernel/encodings/zstd.rs index 928d552dcad..0266fd573aa 100644 --- a/vortex-cuda/src/kernel/encodings/zstd.rs +++ b/vortex-cuda/src/kernel/encodings/zstd.rs @@ -351,11 +351,14 @@ async fn decode_zstd(array: ZstdArray, ctx: &mut CudaExecutionCtx) -> VortexResu #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex::array::IntoArray; use vortex::array::arrays::VarBinViewArray; use vortex::array::assert_arrays_eq; use vortex::encodings::zstd::Zstd; use vortex::error::VortexResult; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; @@ -363,9 +366,11 @@ mod tests { use crate::executor::CudaArrayExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[crate::test] async fn test_cuda_zstd_decompression_utf8() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -390,7 +395,7 @@ mod tests { #[crate::test] async fn test_cuda_zstd_decompression_multiple_frames() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -425,7 +430,7 @@ mod tests { #[crate::test] async fn test_cuda_zstd_decompression_sliced() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -464,7 +469,7 @@ mod tests { /// correct results instead of panicking. #[crate::test] async fn test_cuda_zstd_nullable_falls_back_to_cpu() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/encodings/zstd_buffers.rs b/vortex-cuda/src/kernel/encodings/zstd_buffers.rs index 14acdd0368a..2ea33dff00b 100644 --- a/vortex-cuda/src/kernel/encodings/zstd_buffers.rs +++ b/vortex-cuda/src/kernel/encodings/zstd_buffers.rs @@ -220,22 +220,26 @@ async fn validate_decompress_results( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex::array::IntoArray; use vortex::array::arrays::PrimitiveArray; use vortex::array::arrays::VarBinViewArray; use vortex::array::assert_arrays_eq; use vortex::error::VortexExpect; use vortex::error::VortexResult; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use super::*; use crate::CanonicalCudaExt; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[crate::test] async fn test_cuda_zstd_buffers_decompression_primitive() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); @@ -254,7 +258,7 @@ mod tests { #[crate::test] async fn test_cuda_zstd_buffers_decompression_varbinview() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create execution context"); diff --git a/vortex-cuda/src/kernel/filter/decimal.rs b/vortex-cuda/src/kernel/filter/decimal.rs index bd45c9088fb..c8b303c81b1 100644 --- a/vortex-cuda/src/kernel/filter/decimal.rs +++ b/vortex-cuda/src/kernel/filter/decimal.rs @@ -38,6 +38,8 @@ pub(super) async fn filter_decimal = LazyLock::new(VortexSession::empty); + #[rstest] #[case::i32_sparse( DecimalArray::from_iter([1i32, 2, 3, 4, 5, 6, 7, 8], DecimalDType::new(19, 5)), @@ -89,7 +94,7 @@ mod tests { #[case] input: DecimalArray, #[case] mask: Mask, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create CUDA execution context"); @@ -110,7 +115,7 @@ mod tests { #[crate::test] async fn test_gpu_filter_decimal_large_array() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create CUDA execution context"); diff --git a/vortex-cuda/src/kernel/filter/primitive.rs b/vortex-cuda/src/kernel/filter/primitive.rs index 93c9918d3fd..f49b63e2748 100644 --- a/vortex-cuda/src/kernel/filter/primitive.rs +++ b/vortex-cuda/src/kernel/filter/primitive.rs @@ -38,6 +38,8 @@ where #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::IntoArray; use vortex::array::arrays::FilterArray; @@ -46,6 +48,7 @@ mod tests { use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::mask::Mask; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use crate::CanonicalCudaExt; @@ -53,6 +56,8 @@ mod tests { use crate::executor::CudaExecute; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::i32_sparse( PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6, 7, 8]), @@ -83,7 +88,7 @@ mod tests { #[case] input: PrimitiveArray, #[case] mask: Mask, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create CUDA execution context"); @@ -104,7 +109,7 @@ mod tests { #[crate::test] async fn test_gpu_filter_large_array() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create CUDA execution context"); diff --git a/vortex-cuda/src/kernel/filter/varbinview.rs b/vortex-cuda/src/kernel/filter/varbinview.rs index 746192e045d..702f82cf1b6 100644 --- a/vortex-cuda/src/kernel/filter/varbinview.rs +++ b/vortex-cuda/src/kernel/filter/varbinview.rs @@ -38,6 +38,8 @@ pub(super) async fn filter_varbinview( #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::IntoArray; use vortex::array::arrays::FilterArray; @@ -46,6 +48,7 @@ mod tests { use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::mask::Mask; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use crate::CanonicalCudaExt; @@ -53,6 +56,8 @@ mod tests { use crate::executor::CudaExecute; use crate::session::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::nato( VarBinViewArray::from_iter_str(["alpha", "bravo", "charlie", "delta"]), @@ -69,7 +74,7 @@ mod tests { #[case] input: VarBinViewArray, #[case] mask: Mask, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()) .vortex_expect("failed to create CUDA execution context"); diff --git a/vortex-cuda/src/kernel/patches/types.rs b/vortex-cuda/src/kernel/patches/types.rs index 7ed4308eb1a..77c9e15814e 100644 --- a/vortex-cuda/src/kernel/patches/types.rs +++ b/vortex-cuda/src/kernel/patches/types.rs @@ -221,12 +221,14 @@ pub(crate) fn slice_device_patches( #[cfg(test)] mod tests { use std::ops::Range; + use std::sync::LazyLock; use vortex::array::ArrayRef; use vortex::array::assert_arrays_eq; use vortex::array::buffer::BufferHandle; use vortex::array::validity::Validity::NonNullable; use vortex::buffer::Buffer; + use vortex::session::VortexSession; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::arrays::PrimitiveArray; @@ -237,9 +239,11 @@ mod tests { use super::slice_device_patches; use crate::CudaSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_patches_with_chunk_offsets() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test creating patches with pre-computed chunk_offsets let indices = PrimitiveArray::from_iter([0u32, 500, 1024, 2000]); let values = PrimitiveArray::from_iter([10u32, 20, 30, 40]); @@ -321,7 +325,7 @@ mod tests { #[case] chunk_offsets: ArrayRef, #[case] expected: ArrayRef, ) -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())?; let indices = PrimitiveArray::from_iter([100u32, 1100, 2100, 3100, 4100]); let values = PrimitiveArray::from_iter([10u32, 11, 12, 13, 14]); diff --git a/vortex-cuda/src/lib.rs b/vortex-cuda/src/lib.rs index 21cb808558d..5a13a2f0f54 100644 --- a/vortex-cuda/src/lib.rs +++ b/vortex-cuda/src/lib.rs @@ -151,5 +151,5 @@ pub fn initialize_cuda(session: &CudaSession) { /// Panics if CUDA device 0 cannot be initialized (the same contract as [`CudaSession::default`]). #[cfg(any(test, feature = "_test-harness"))] pub fn cuda_session() -> vortex::session::VortexSession { - vortex::array::array_session().with::() + vortex::session::VortexSession::empty().with::() } diff --git a/vortex-cuda/src/stream.rs b/vortex-cuda/src/stream.rs index 74a139f875e..a6515b1f8db 100644 --- a/vortex-cuda/src/stream.rs +++ b/vortex-cuda/src/stream.rs @@ -269,6 +269,7 @@ fn register_stream_callback(stream: &CudaStream) -> VortexResult = LazyLock::new(VortexSession::empty); + #[test] fn test_padded_device_allocation_len() -> VortexResult<()> { assert_eq!(padded_device_allocation_len::(0)?, 0); @@ -359,7 +363,7 @@ mod tests { assert_eq!(sliced.len(), 9); assert!(sliced.buffer_handles()[0].is_on_device()); - let mut cpu_ctx = vortex_array::array_session().create_execution_ctx(); + let mut cpu_ctx = SESSION.create_execution_ctx(); let host = sliced .execute::(&mut cpu_ctx)? .into_host(&mut cpu_ctx) diff --git a/vortex-datafusion/src/persistent/sink.rs b/vortex-datafusion/src/persistent/sink.rs index 6acb2fd54dc..5d9b24775dc 100644 --- a/vortex-datafusion/src/persistent/sink.rs +++ b/vortex-datafusion/src/persistent/sink.rs @@ -210,6 +210,7 @@ impl FileSink for VortexSink { #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use arrow_schema::DataType; use arrow_schema::Field; @@ -244,6 +245,8 @@ mod tests { use crate::common_tests::TestSessionContext; use crate::persistent::VortexFormatFactory; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[tokio::test] async fn test_insert_into_sql() -> anyhow::Result<()> { let ctx = TestSessionContext::default(); @@ -518,7 +521,6 @@ mod tests { #[test] fn test_display_as() { - let session = VortexSession::empty(); let table_schema = TableSchema::from(Arc::new(Schema::empty())); let config = FileSinkConfig { @@ -538,7 +540,7 @@ mod tests { VortexSink::new( config.clone(), Arc::clone(table_schema.file_schema()), - session.clone(), + SESSION.clone(), ) }; diff --git a/vortex-duckdb/src/convert/vector.rs b/vortex-duckdb/src/convert/vector.rs index 80248cc3321..77e57226928 100644 --- a/vortex-duckdb/src/convert/vector.rs +++ b/vortex-duckdb/src/convert/vector.rs @@ -435,6 +435,7 @@ pub fn data_chunk_to_vortex( #[cfg(test)] mod tests { use std::ffi::CString; + use std::sync::LazyLock; use geo_types::point; use vortex::array::VortexSessionExecute; @@ -448,7 +449,7 @@ mod tests { use vortex::array::assert_arrays_eq; use vortex::error::VortexExpect; use vortex::mask::Mask; - use vortex_array::array_session; + use vortex::session::VortexSession; use vortex_spatial::extension::WellKnownBinaryData; use wkb::writer::WriteOptions; use wkb::writer::write_point; @@ -459,9 +460,11 @@ mod tests { use crate::duckdb::LogicalType; use crate::duckdb::Vector; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_integer_vector_conversion() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![1i32, 2, 3, 4, 5]; let len = values.len(); @@ -483,7 +486,7 @@ mod tests { #[test] fn test_timestamp_vector_conversion() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![1_703_980_800_000_000_i64, 0i64, -86_400_000_000_i64]; // microseconds let len = values.len(); @@ -508,7 +511,7 @@ mod tests { #[test] fn test_timestamp_seconds_vector_conversion() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![1_703_980_800_i64, 0i64, -86_400_i64]; // seconds let len = values.len(); @@ -533,7 +536,7 @@ mod tests { #[test] fn test_timestamp_milliseconds_vector_conversion() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![1_703_980_800_000_i64, 0i64, -86_400_000_i64]; // milliseconds let len = values.len(); @@ -558,7 +561,7 @@ mod tests { #[test] fn test_timestamp_with_nulls_conversion() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![1_703_980_800_000_000_i64, 0i64, -86_400_000_000_i64]; let len = values.len(); @@ -614,7 +617,7 @@ mod tests { // Test conversion let result = flat_vector_to_vortex(&vector, len).unwrap(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = TemporalArray::new_timestamp( PrimitiveArray::from_option_iter(values.into_iter().map(Some)).into_array(), TimeUnit::Microseconds, @@ -625,7 +628,7 @@ mod tests { #[test] fn test_timestamp_single_value() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![1_703_980_800_000_000_i64]; // Single microsecond timestamp let len = values.len(); @@ -650,7 +653,7 @@ mod tests { #[test] fn test_boolean_vector_conversion() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![true, false, true, false]; let len = values.len(); @@ -671,7 +674,7 @@ mod tests { #[test] fn test_vector_with_nulls() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![1i32, 2, 3]; let len = values.len(); @@ -719,7 +722,7 @@ mod tests { // Test conversion let result = flat_vector_to_vortex(&vector, len).unwrap(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let vortex_array = result.execute::(&mut ctx).unwrap(); assert_eq!(vortex_array.len(), len); @@ -741,7 +744,7 @@ mod tests { #[test] fn test_fixed_sized_list() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![1i32, 2, 3, 4]; let len = 1; @@ -780,7 +783,7 @@ mod tests { #[test] fn test_empty_struct() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let len = 4; let logical_type = LogicalType::struct_type([], []) .vortex_expect("LogicalTypeRef creation should succeed for test data"); @@ -805,7 +808,7 @@ mod tests { #[test] fn test_struct() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values1 = vec![1i32, 2, 3, 4]; let values2 = vec![5i32, 6, 7, 8]; let len = values1.len(); @@ -869,7 +872,7 @@ mod tests { #[test] fn test_list_with_trailing_null() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Regression test: when the last list entry is null, its offset/length may be 0/0, // so we can't use the last entry to compute child vector length. let child_values = vec![1i32, 2, 3, 4]; @@ -924,7 +927,7 @@ mod tests { #[test] fn test_list_out_of_order() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Regression test: list views can be out of order in DuckDB. The child vector length // must be computed as the maximum end offset, not just the last entry's end offset. let child_values = vec![1i32, 2, 3, 4]; @@ -972,7 +975,7 @@ mod tests { #[test] fn test_list_null_garbage_data() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Test that null list entries with garbage offset/size values don't cause issues. // DuckDB doesn't guarantee valid offset/size for null list views, so we must check // validity before reading the offset/size values. @@ -1056,7 +1059,7 @@ mod tests { #[test] fn test_geometry_vector_conversion() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut wkb_a: Vec = Vec::new(); write_point( diff --git a/vortex-duckdb/src/duckdb/vector.rs b/vortex-duckdb/src/duckdb/vector.rs index beb6c82436a..1d37ff9d6ef 100644 --- a/vortex-duckdb/src/duckdb/vector.rs +++ b/vortex-duckdb/src/duckdb/vector.rs @@ -385,14 +385,18 @@ impl ValidityRef<'_> { #[cfg(test)] mod tests { - use vortex::array::array_session; + use std::sync::LazyLock; + use vortex::mask::Mask; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; use super::*; use crate::cpp::DUCKDB_TYPE; use crate::duckdb::SelectionVector; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_create_validity_all_valid() { let len = 10; @@ -422,7 +426,7 @@ mod tests { let validity = validity.to_validity(); assert_eq!(validity.maybe_len(), Some(len)); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( validity.execute_mask(len, &mut ctx).unwrap(), Mask::from_indices(len, vec![0, 2, 4, 5, 6, 8, 9]) @@ -442,7 +446,7 @@ mod tests { let validity = validity.to_validity(); assert!( validity - .execute_is_null(0, &mut array_session().create_execution_ctx()) + .execute_is_null(0, &mut SESSION.create_execution_ctx()) .unwrap() ); } @@ -459,7 +463,7 @@ mod tests { let validity = validity.to_validity(); assert!( validity - .execute_is_valid(0, &mut array_session().create_execution_ctx()) + .execute_is_valid(0, &mut SESSION.create_execution_ctx()) .unwrap() ); } diff --git a/vortex-duckdb/src/e2e_test/vortex_scan_test.rs b/vortex-duckdb/src/e2e_test/vortex_scan_test.rs index ec9ab9860a2..628088f36d2 100644 --- a/vortex-duckdb/src/e2e_test/vortex_scan_test.rs +++ b/vortex-duckdb/src/e2e_test/vortex_scan_test.rs @@ -22,7 +22,6 @@ use rstest::rstest; use tempfile::NamedTempFile; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; -use vortex::array::array_session; use vortex::array::arrays::BoolArray; use vortex::array::arrays::ConstantArray; use vortex::array::arrays::DictArray; @@ -1018,7 +1017,7 @@ async fn write_vortex_file_with_encodings() -> NamedTempFile { // 4. Run-End let run_ends = buffer![3u32, 5]; let run_values = buffer![100i32, 200]; - let mut rle_ctx = array_session().create_execution_ctx(); + let mut rle_ctx = SESSION.create_execution_ctx(); let rle_array = RunEnd::try_new(run_ends.into_array(), run_values.into_array(), &mut rle_ctx).unwrap(); diff --git a/vortex-ffi/src/array.rs b/vortex-ffi/src/array.rs index e0a894f8345..e339215c2e0 100644 --- a/vortex-ffi/src/array.rs +++ b/vortex-ffi/src/array.rs @@ -723,10 +723,10 @@ mod tests { use std::ptr; use std::slice::from_raw_parts; use std::sync::Arc; + use std::sync::LazyLock; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; - use vortex::array::array_session; use vortex::array::arrays::BoolArray; use vortex::array::arrays::PrimitiveArray; use vortex::array::arrays::StructArray; @@ -737,6 +737,7 @@ mod tests { use vortex::expr::eq; use vortex::expr::lit; use vortex::expr::root; + use vortex::session::VortexSession; use crate::array::*; use crate::dtype::vx_dtype_free; @@ -751,6 +752,8 @@ mod tests { use crate::tests::assert_error; use crate::tests::assert_no_error; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + unsafe fn get_i32(session: *const vx_session, array: *const vx_array, index: usize) -> i32 { let mut error = ptr::null_mut(); let scalar = unsafe { vx_array_get_scalar(session, array, index, &raw mut error) }; @@ -1025,7 +1028,7 @@ mod tests { assert!(!res.is_null()); { let res = vx_array::as_ref(res); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = BoolArray::from_iter([Some(false), None, Some(true), Some(true)]); assert_arrays_eq!(res, expected, &mut ctx); } @@ -1110,7 +1113,7 @@ mod tests { assert_no_error(error); assert!(!vx.is_null()); assert!(ffi_array.is_released()); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = StructArray::try_from_iter([ ("a", buffer![1i32, 2, 3].into_array()), ( diff --git a/vortex-ffi/src/expression.rs b/vortex-ffi/src/expression.rs index 63f0c4cc7fa..970e81fa126 100644 --- a/vortex-ffi/src/expression.rs +++ b/vortex-ffi/src/expression.rs @@ -309,10 +309,10 @@ pub unsafe extern "C" fn vx_expression_list_contains( #[cfg(test)] mod tests { use std::ptr; + use std::sync::LazyLock; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; - use vortex::array::array_session; use vortex::array::arrays::BoolArray; use vortex::array::arrays::ListArray; use vortex::array::arrays::PrimitiveArray; @@ -323,6 +323,7 @@ mod tests { use vortex::buffer::buffer; use vortex::dtype::Nullability; use vortex::scalar::Scalar; + use vortex::session::VortexSession; use crate::array::vx_array; use crate::array::vx_array_apply; @@ -343,6 +344,8 @@ mod tests { use crate::scalar::vx_scalar_new_i32; use crate::string::vx_view; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn struct_array() -> (StructArray, VarBinViewArray, PrimitiveArray) { let names_array = VarBinViewArray::from_iter_str(["Alice", "Bob", "Charlie"]); let ages_buffer = buffer![30u8, 25u8, 35u8]; @@ -359,7 +362,7 @@ mod tests { #[test] #[cfg_attr(miri, ignore)] fn test_get_item() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let (array, names_array, ages_array) = struct_array(); unsafe { let root = vx_expression_root(); @@ -405,7 +408,7 @@ mod tests { #[test] #[cfg_attr(miri, ignore)] fn test_literal() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable).into_array(); @@ -451,7 +454,7 @@ mod tests { #[test] #[cfg_attr(miri, ignore)] fn test_select() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let (array, ..) = struct_array(); unsafe { let root = vx_expression_root(); @@ -490,7 +493,7 @@ mod tests { #[test] #[cfg_attr(miri, ignore)] fn test_and_or() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let col1 = BoolArray::from_iter([true, false, true, true]); let col2 = BoolArray::from_iter([false, true, true, false]); let col3 = BoolArray::from_iter([false, true, true, true]); @@ -559,7 +562,7 @@ mod tests { #[test] #[cfg_attr(miri, ignore)] fn test_list_contains() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let elements = buffer![1i32, 2, 3, 4, 5].into_array(); let offsets = buffer![0u32, 2, 5, 5].into_array(); let array = ListArray::try_new(elements, offsets, Validity::NonNullable, &mut ctx).unwrap(); diff --git a/vortex-ffi/src/scan.rs b/vortex-ffi/src/scan.rs index 65671e82cd9..b58caddfb69 100644 --- a/vortex-ffi/src/scan.rs +++ b/vortex-ffi/src/scan.rs @@ -446,6 +446,7 @@ pub unsafe extern "C-unwind" fn vx_partition_next( #[cfg(test)] mod tests { use std::ptr; + use std::sync::LazyLock; use vortex::VortexSessionDefault; use vortex::array::IntoArray; @@ -456,7 +457,6 @@ mod tests { use vortex::array::validity::Validity; use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::struct_::StructArrayExt; use vortex_array::assert_arrays_eq; @@ -491,6 +491,8 @@ mod tests { use crate::tests::assert_no_error; use crate::tests::write_sample; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Perform a scan with options over a sample file, return owned read array and /// original generated array for the sample file. fn scan(options: *const vx_scan_options) -> (*const vx_array, StructArray) { @@ -561,7 +563,7 @@ mod tests { #[test] #[cfg_attr(miri, ignore)] fn test_no_options() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let (array, struct_array) = scan(ptr::null()); assert_arrays_eq!(vx_array::as_ref(array), struct_array, &mut ctx); unsafe { vx_array_free(array) }; @@ -570,7 +572,7 @@ mod tests { #[test] #[cfg_attr(miri, ignore)] fn test_project_all() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let opts = vx_scan_options::default(); let (array, struct_array) = scan(&raw const opts); assert_arrays_eq!(vx_array::as_ref(array), struct_array, &mut ctx); @@ -581,7 +583,7 @@ mod tests { #[cfg_attr(miri, ignore)] fn test_project_single_field() { unsafe { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let root = vx_expression_root(); let mut opts = vx_scan_options::default(); @@ -659,7 +661,7 @@ mod tests { ..Default::default() }; let (array, source) = scan(&raw const opts); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = expected_rows(&source, &(100..200).collect::>()); assert_arrays_eq!(vx_array::as_ref(array), expected, &mut ctx); @@ -692,7 +694,7 @@ mod tests { ..Default::default() }; let (array, _) = scan(&raw const opts); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = PrimitiveArray::from_option_iter((100u64..200).map(Some)); assert_arrays_eq!(vx_array::as_ref(array), expected, &mut ctx); @@ -714,7 +716,7 @@ mod tests { ..Default::default() }; let (array, source) = scan(&raw const opts); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = expected_rows(&source, &(50..100).collect::>()); assert_arrays_eq!(vx_array::as_ref(array), expected, &mut ctx); unsafe { vx_array_free(array) }; @@ -733,7 +735,7 @@ mod tests { ..Default::default() }; let (array, source) = scan(&raw const opts); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = expected_rows(&source, &[0, 50, 100, 150, 199]); assert_arrays_eq!(vx_array::as_ref(array), expected, &mut ctx); unsafe { vx_array_free(array) }; @@ -754,7 +756,7 @@ mod tests { #[test] #[cfg_attr(miri, ignore)] fn test_ordered() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let opts = vx_scan_options { ordered: true, ..Default::default() diff --git a/vortex-ffi/src/struct_array.rs b/vortex-ffi/src/struct_array.rs index bb134c237b3..e1c00877866 100644 --- a/vortex-ffi/src/struct_array.rs +++ b/vortex-ffi/src/struct_array.rs @@ -128,16 +128,17 @@ pub extern "C-unwind" fn vx_struct_column_builder_finalize( mod tests { use std::ffi::c_void; use std::ptr; + use std::sync::LazyLock; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; - use vortex::array::array_session; use vortex::array::arrays::PrimitiveArray; use vortex::array::arrays::StructArray; use vortex::array::arrays::VarBinViewArray; use vortex::array::assert_arrays_eq; use vortex::array::validity::Validity; use vortex::buffer::buffer; + use vortex::session::VortexSession; use crate::array::vx_array; use crate::array::vx_array_free; @@ -153,6 +154,8 @@ mod tests { use crate::struct_array::vx_struct_column_builder_free; use crate::struct_array::vx_struct_column_builder_new; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn test_empty() { let validity = vx_validity { @@ -169,7 +172,7 @@ mod tests { #[test] #[cfg_attr(miri, ignore)] fn test_many() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let names = ["age", "name"]; let age_field = PrimitiveArray::new(buffer![30u8, 25u8, 35u8], Validity::NonNullable); let name_field = VarBinViewArray::from_iter_str(["Alice", "Bob", "Charlie"]); diff --git a/vortex-file/benches/split_collection.rs b/vortex-file/benches/split_collection.rs index 951a3c21adb..ca95db237af 100644 --- a/vortex-file/benches/split_collection.rs +++ b/vortex-file/benches/split_collection.rs @@ -18,10 +18,17 @@ use std::sync::LazyLock; use divan::Bencher; use mimalloc::MiMalloc; use vortex_array::IntoArray; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::StructArray; use vortex_array::dtype::Field; use vortex_array::dtype::FieldMask; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_btrblocks::BtrBlocksCompressorBuilder; use vortex_buffer::Buffer; use vortex_buffer::ByteBufferMut; @@ -43,6 +50,7 @@ use vortex_utils::aliases::hash_map::HashMap; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -60,7 +68,14 @@ static RUNTIME: LazyLock = LazyLock::new(|| { static SESSION: LazyLock = LazyLock::new(|| { let _guard = RUNTIME.enter(); - let session = vortex_array::array_session() + let session = VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() .with::() .with::() .with_tokio(); diff --git a/vortex-file/src/footer/deserializer.rs b/vortex-file/src/footer/deserializer.rs index b703a47c274..77320ef2204 100644 --- a/vortex-file/src/footer/deserializer.rs +++ b/vortex-file/src/footer/deserializer.rs @@ -361,10 +361,10 @@ fn checked_segment_slice<'a>( #[cfg(test)] mod tests { use rstest::rstest; - use vortex_array::array_session; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; use vortex_array::flatbuffers::WriteFlatBufferExt; + use vortex_session::VortexSession; use super::*; @@ -428,7 +428,7 @@ mod tests { let buffer = eof_buffer(&postscript)?; let file_size = buffer.len() as u64; - let mut deserializer = FooterDeserializer::new(buffer, array_session()) + let mut deserializer = FooterDeserializer::new(buffer, VortexSession::empty()) .with_dtype(DType::Primitive(PType::I32, Nullability::NonNullable)) .with_size(file_size); let err = deserializer.deserialize().unwrap_err(); @@ -448,7 +448,7 @@ mod tests { let buffer = eof_buffer(&postscript)?; let declared_size = buffer.len() as u64 - 1; - let mut deserializer = FooterDeserializer::new(buffer, array_session()) + let mut deserializer = FooterDeserializer::new(buffer, VortexSession::empty()) .with_dtype(DType::Primitive(PType::I32, Nullability::NonNullable)) .with_size(declared_size); let err = deserializer.deserialize().unwrap_err(); diff --git a/vortex-file/src/footer/field_sizes.rs b/vortex-file/src/footer/field_sizes.rs index 6411e1982fb..afd47353d5b 100644 --- a/vortex-file/src/footer/field_sizes.rs +++ b/vortex-file/src/footer/field_sizes.rs @@ -122,7 +122,6 @@ mod tests { use std::sync::LazyLock; use vortex_array::IntoArray; - use vortex_array::array_session; use vortex_array::arrays::StructArray; use vortex_array::dtype::FieldPath; use vortex_array::field_path; @@ -137,7 +136,7 @@ mod tests { use crate::writer::WriteSummary; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session() + let session = VortexSession::empty() .with::() .with::(); crate::register_default_encodings(&session); diff --git a/vortex-file/src/lib.rs b/vortex-file/src/lib.rs index 707de8bb47e..1c309112078 100644 --- a/vortex-file/src/lib.rs +++ b/vortex-file/src/lib.rs @@ -275,18 +275,18 @@ pub(crate) fn enable_all_registered_array_encodings(session: &VortexSession) { #[cfg(test)] mod default_encoding_tests { use vortex_array::VTable as _; - use vortex_array::array_session; use vortex_array::arrays::Filter; use vortex_array::optimizer::kernels::ArrayKernelsExt as _; use vortex_array::session::ArraySessionExt as _; use vortex_fsst::FSST; use vortex_onpair::OnPair; + use vortex_session::VortexSession; use crate::register_default_encodings; #[test] fn register_default_encodings_registers_external_execute_parent_kernels() { - let session = array_session(); + let session = VortexSession::empty(); assert!(!session.arrays().registry().contains_key(&FSST.id())); assert!(!session.kernels().has_execute_parent(Filter.id(), FSST.id())); diff --git a/vortex-file/src/multi/mod.rs b/vortex-file/src/multi/mod.rs index 57af2974980..03a80171ec5 100644 --- a/vortex-file/src/multi/mod.rs +++ b/vortex-file/src/multi/mod.rs @@ -302,7 +302,6 @@ mod tests { use std::fmt; use vortex_array::IntoArray; - use vortex_array::array_session; use vortex_buffer::ByteBuffer; use vortex_buffer::ByteBufferMut; use vortex_buffer::buffer; @@ -310,6 +309,7 @@ mod tests { use vortex_io::filesystem::FileSystem; use vortex_io::session::RuntimeSession; use vortex_layout::session::LayoutSession; + use vortex_session::VortexSession; use super::*; use crate::WriteOptionsSessionExt; @@ -347,7 +347,7 @@ mod tests { } async fn assert_cached_footer_metadata_order(default_first: bool) -> VortexResult<()> { - let session = array_session() + let session = VortexSession::empty() .with::() .with::() .with::(); @@ -448,7 +448,7 @@ mod tests { // cache must not let one file's metadata leak into another (URI isolation). #[tokio::test] async fn test_multi_file_metadata_isolated_per_uri() -> VortexResult<()> { - let session = array_session() + let session = VortexSession::empty() .with::() .with::() .with::(); diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs index 5c8c7177fc9..3e06dbcfbf5 100644 --- a/vortex-file/src/open.rs +++ b/vortex-file/src/open.rs @@ -541,7 +541,7 @@ mod tests { use crate::footer::SegmentSpec; fn test_session() -> VortexSession { - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::(); crate::register_default_encodings(&session); @@ -605,7 +605,7 @@ mod tests { #[tokio::test] async fn test_initial_read_size() { - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::(); @@ -667,7 +667,7 @@ mod tests { #[tokio::test] async fn test_metadata_outside_initial_read_uses_targeted_read() -> VortexResult<()> { - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::(); crate::register_default_encodings(&session); @@ -741,7 +741,7 @@ mod tests { #[tokio::test] async fn test_with_footer_include_metadata_open_buffer_resolves() -> VortexResult<()> { - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::(); crate::register_default_encodings(&session); @@ -782,7 +782,7 @@ mod tests { #[cfg(not(target_arch = "wasm32"))] #[tokio::test] async fn test_open_path_uses_memory_session_allocator() { - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::(); diff --git a/vortex-file/src/tests.rs b/vortex-file/src/tests.rs index 368e56d970f..13746255c03 100644 --- a/vortex-file/src/tests.rs +++ b/vortex-file/src/tests.rs @@ -20,7 +20,6 @@ use tempfile::tempdir; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ConstantArray; @@ -119,7 +118,7 @@ use crate::WriteOptionsSessionExt; use crate::flatbuffers::footer as fb; use crate::footer::SegmentSpec; static SESSION: LazyLock = LazyLock::new(|| { - let session = array_session() + let session = VortexSession::empty() .with::() .with::(); @@ -251,7 +250,7 @@ async fn decimal_writer_uses_default_or_session_restrictions( #[case] custom_strategy: bool, #[case] explicit_compressor: bool, ) -> VortexResult<()> { - let session = array_session() + let session = VortexSession::empty() .with::() .with::() .with::(); @@ -1849,7 +1848,7 @@ async fn test_buffered_bytes_are_writer_scoped() -> VortexResult<()> { #[tokio::test] async fn test_encoding_registered_after_write_options() -> VortexResult<()> { // A session that does not know about ZigZag yet. - let session = array_session() + let session = VortexSession::empty() .with::() .with::() .with::(); @@ -2047,13 +2046,16 @@ async fn nested_list_of_list_roundtrip() -> VortexResult<()> { #[tokio::test] #[cfg_attr(miri, ignore)] async fn nested_empty_list_roundtrip(#[case] validity: Validity) -> VortexResult<()> { + let mut ctx = SESSION.create_execution_ctx(); let inner = ListArray::try_new( PrimitiveArray::new::(buffer![], Validity::NonNullable).into_array(), buffer![0u32].into_array(), Validity::NonNullable, + &mut ctx, )? .into_array(); - let outer = ListArray::try_new(inner, buffer![0u32, 0, 0].into_array(), validity)?.into_array(); + let outer = ListArray::try_new(inner, buffer![0u32, 0, 0].into_array(), validity, &mut ctx)? + .into_array(); let array = StructArray::from_fields(&[("nested", outer)])?.into_array(); let result = write_read_roundtrip(array.clone()).await?; diff --git a/vortex-file/src/v2/file_stats_reader.rs b/vortex-file/src/v2/file_stats_reader.rs index e70ea431eea..d971542cc43 100644 --- a/vortex-file/src/v2/file_stats_reader.rs +++ b/vortex-file/src/v2/file_stats_reader.rs @@ -206,7 +206,7 @@ mod tests { use super::*; static SESSION: LazyLock = LazyLock::new(|| { - vortex_array::array_session() + VortexSession::empty() .with::() .with::() }); diff --git a/vortex-file/src/writer.rs b/vortex-file/src/writer.rs index 2a6fb60847a..a5208014bfd 100644 --- a/vortex-file/src/writer.rs +++ b/vortex-file/src/writer.rs @@ -762,7 +762,6 @@ impl WriteSummary { mod tests { use rstest::rstest; use vortex_array::VTable; - use vortex_array::array_session; use vortex_array::arrays::Bool; use vortex_array::arrays::Primitive; use vortex_buffer::ByteBuffer; @@ -774,6 +773,7 @@ mod tests { use vortex_edition::EditionMember; use vortex_edition::EditionSession; use vortex_edition::EditionSessionExt; + use vortex_session::VortexSession; use vortex_session::registry::CachedId; use super::*; @@ -789,7 +789,7 @@ mod tests { added: &[EditionMember::array(&"vortex.primitive")], }; - let session = array_session().with::(); + let session = VortexSession::empty().with::(); session.register_edition(&DECLARATION)?; session.enable_edition(EDITION)?; @@ -815,7 +815,7 @@ mod tests { ], }; - let session = array_session().with::(); + let session = VortexSession::empty().with::(); session.register_edition(&DECLARATION)?; session.enable_edition(EDITION)?; @@ -828,7 +828,7 @@ mod tests { #[test] fn disabling_editions_allows_all_registered_array_ids() { - let session = array_session(); + let session = VortexSession::empty(); let registered_ids = session .arrays() .registry() @@ -851,7 +851,7 @@ mod tests { added: &[EditionMember::array(&"vortex.primitive")], }; - let session = array_session().with::(); + let session = VortexSession::empty().with::(); session.register_edition(&ARRAYS_ONLY)?; session.enable_edition(EDITION)?; assert!(edition_filter(&session, ComponentKind::Layout).is_empty()); @@ -895,7 +895,7 @@ mod tests { added: &[EditionMember::dtype(&"vortex.date")], }; - let session = array_session().with::(); + let session = VortexSession::empty().with::(); session.register_edition(&DECLARATION)?; session.enable_edition(EDITION)?; @@ -916,10 +916,12 @@ mod tests { } fn write_options_with_keys(keys: &[String]) -> VortexWriteOptions { - array_session().write_options().with_metadata_segments( - keys.iter() - .map(|key| (key.clone(), ByteBuffer::copy_from(b"value"))), - ) + VortexSession::empty() + .write_options() + .with_metadata_segments( + keys.iter() + .map(|key| (key.clone(), ByteBuffer::copy_from(b"value"))), + ) } #[rstest] diff --git a/vortex-file/tests/issue_8819_footer_segment_oob.rs b/vortex-file/tests/issue_8819_footer_segment_oob.rs index 93e4ab46db3..6c2cafb797a 100644 --- a/vortex-file/tests/issue_8819_footer_segment_oob.rs +++ b/vortex-file/tests/issue_8819_footer_segment_oob.rs @@ -28,7 +28,7 @@ mod common; use common::enable_all_registered_array_encodings; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::(); diff --git a/vortex-file/tests/single_thread_runtime.rs b/vortex-file/tests/single_thread_runtime.rs index 87f8cb9f483..71888971d7b 100644 --- a/vortex-file/tests/single_thread_runtime.rs +++ b/vortex-file/tests/single_thread_runtime.rs @@ -28,6 +28,7 @@ use vortex_io::runtime::single::SingleThreadRuntime; use vortex_io::session::RuntimeSession; use vortex_io::session::RuntimeSessionExt; use vortex_layout::session::LayoutSession; +use vortex_session::VortexSession; mod common; @@ -51,7 +52,7 @@ fn test_array() -> ArrayRef { fn roundtrip_on_single_thread_runtime() -> VortexResult<()> { let runtime = SingleThreadRuntime::default(); - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::() .with_handle(runtime.handle()); diff --git a/vortex-file/tests/test_write_table.rs b/vortex-file/tests/test_write_table.rs index 28c2cdeeb3b..73e0493cf6a 100644 --- a/vortex-file/tests/test_write_table.rs +++ b/vortex-file/tests/test_write_table.rs @@ -37,7 +37,7 @@ mod common; use common::enable_all_registered_array_encodings; static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::(); diff --git a/vortex-json/src/arrow.rs b/vortex-json/src/arrow.rs index f159867042a..cf9cef8c586 100644 --- a/vortex-json/src/arrow.rs +++ b/vortex-json/src/arrow.rs @@ -150,6 +150,7 @@ impl ArrowImportVTable for Json { mod tests { use std::sync::Arc; + use std::sync::LazyLock; use arrow_array::Array; use arrow_array::ArrayRef as ArrowArrayRef; @@ -173,16 +174,20 @@ mod tests { use vortex_arrow::CompactBuffers; use vortex_error::VortexExpect; use vortex_error::VortexResult; + use vortex_session::VortexSession; use crate::Json; use crate::initialize; + static SESSION: LazyLock = LazyLock::new(|| { + let session = VortexSession::empty(); + initialize(&session); + session + }); + /// Export a JSON extension array to Arrow's canonical JSON extension. #[test] fn exports_json_extension_array_as_arrow_json() -> VortexResult<()> { - let session = vortex_array::array_session(); - initialize(&session); - let storage = VarBinArray::from_iter( [Some("{\"id\":1}"), Some("{\"id\":2}")], vortex_array::dtype::DType::Utf8(Nullability::NonNullable), @@ -192,16 +197,16 @@ mod tests { let array = ExtensionArray::new(ext_dtype, storage).into_array(); - let field = session.arrow().to_arrow_field("data", array.dtype())?; + let field = SESSION.arrow().to_arrow_field("data", array.dtype())?; assert_eq!(field.extension_type_name(), Some(ArrowJson::NAME)); assert_eq!(field.name(), "data"); assert!(!field.is_nullable()); ArrowJson::try_new_from_field_metadata(field.data_type(), field.metadata())?; - let exported = session.arrow().execute_arrow( + let exported = SESSION.arrow().execute_arrow( array, Some(&field), - &mut session.create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )?; assert!(exported.data_type().is_string()); @@ -217,14 +222,11 @@ mod tests { /// Import Arrow's canonical JSON extension as a Vortex JSON extension array. #[test] fn imports_arrow_json_extension_array_as_vortex_json() -> VortexResult<()> { - let session = vortex_array::array_session(); - initialize(&session); - let mut field = Field::new("data", DataType::Utf8, false); field.try_with_extension_type(ArrowJson::default())?; let array = Arc::new(StringArray::from(vec!["{\"id\":1}", "{\"id\":2}"])) as ArrowArrayRef; - let imported = session.arrow().from_arrow_array(array, &field)?; + let imported = SESSION.arrow().from_arrow_array(array, &field)?; let ext_dtype = imported .dtype() .as_extension_opt() @@ -235,10 +237,10 @@ mod tests { &vortex_array::dtype::DType::Utf8(Nullability::NonNullable) ); - let exported = session.arrow().execute_arrow( + let exported = SESSION.arrow().execute_arrow( imported, Some(&field), - &mut session.create_execution_ctx(), + &mut SESSION.create_execution_ctx(), )?; let strings = exported.as_string::(); assert_eq!( @@ -251,9 +253,7 @@ mod tests { /// The plugin must forward export options to its storage export. #[test] fn export_options_reach_json_storage() -> VortexResult<()> { - let session = vortex_array::array_session(); - initialize(&session); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let views = VarBinViewArray::from_iter_str((0..64).map(|i| format!("{{\"id\":{i:>32}}}"))); let backing = views.data_buffers()[0].as_host().as_ptr(); @@ -263,12 +263,12 @@ mod tests { .take(PrimitiveArray::from_iter([0u32, 48]).into_array())?; let ext_dtype = ExtDType::::try_new(EmptyMetadata, storage.dtype().clone())?.erased(); let array = ExtensionArray::new(ext_dtype, storage).into_array(); - let field = session.arrow().to_arrow_field("data", array.dtype())?; + let field = SESSION.arrow().to_arrow_field("data", array.dtype())?; let retains_backing = |options: &ArrowExportOptions, ctx: &mut vortex_array::ExecutionCtx| -> VortexResult { - let exported = session.arrow().exporter(options).execute_arrow( + let exported = SESSION.arrow().exporter(options).execute_arrow( array.clone(), Some(&field), ctx, diff --git a/vortex-json/src/editions.rs b/vortex-json/src/editions.rs index 239d55042d6..2cd428b5942 100644 --- a/vortex-json/src/editions.rs +++ b/vortex-json/src/editions.rs @@ -43,11 +43,12 @@ mod tests { use vortex_edition::EditionSessionExt; use vortex_edition::test_harness::validate_edition; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::*; - fn json_session() -> vortex_session::VortexSession { - let session = vortex_array::array_session(); + fn json_session() -> VortexSession { + let session = VortexSession::empty(); crate::initialize(&session); session } diff --git a/vortex-layout/benches/aggregate_partial_merge.rs b/vortex-layout/benches/aggregate_partial_merge.rs index 65e24122442..e6c8e46e468 100644 --- a/vortex-layout/benches/aggregate_partial_merge.rs +++ b/vortex-layout/benches/aggregate_partial_merge.rs @@ -30,11 +30,18 @@ use vortex_array::aggregate_fn::AggregateFnRef; use vortex_array::aggregate_fn::AggregateFnVTableExt; use vortex_array::aggregate_fn::NumericalAggregateOpts; use vortex_array::aggregate_fn::fns::sum_v2::SumV2; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_layout::layouts::zoned::aggregates::bloom_filter::BloomFilter; @@ -50,7 +57,16 @@ fn main() { divan::main(); } -static SESSION: LazyLock = LazyLock::new(vortex_array::array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Zones merged per iteration. const ZONE_COUNT: usize = 16; diff --git a/vortex-layout/benches/pipeline_scan.rs b/vortex-layout/benches/pipeline_scan.rs index db4beeaa043..28370507291 100644 --- a/vortex-layout/benches/pipeline_scan.rs +++ b/vortex-layout/benches/pipeline_scan.rs @@ -6,16 +6,24 @@ #![expect(clippy::unwrap_used)] use std::hint::black_box; +use std::sync::LazyLock; use divan::Bencher; use mimalloc::MiMalloc; use vortex_array::ArrayContext; use vortex_array::IntoArray; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::buffer::BufferHandle; use vortex_array::dtype::Nullability; use vortex_array::dtype::StructFields; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; use vortex_array::serde::SerializeOptions; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_buffer::Alignment; use vortex_buffer::ByteBufferMut; use vortex_layout::plan::physical::PackPlan; @@ -29,12 +37,25 @@ use vortex_layout::session::LayoutSession; use vortex_session::VortexSession; use vortex_session::registry::ReadContext; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; const ROWS: u64 = 1024; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -46,13 +67,12 @@ struct Fixture { impl Fixture { fn new(columns: u32) -> Self { - let session = vortex_array::array_session().with::(); let array = PrimitiveArray::from_iter(0_i32..1024).into_array(); let context = ArrayContext::empty(); let buffers = array .serialize( &context, - &session, + &SESSION, &SerializeOptions { offset: 0, include_padding: true, @@ -79,7 +99,7 @@ impl Fixture { }) .collect(); Self { - session, + session: SESSION.clone(), plan: PackPlan::try_new(fields, Nullability::NonNullable, ROWS, children, None) .unwrap() .into_plan(), diff --git a/vortex-layout/benches/zone_map_prune.rs b/vortex-layout/benches/zone_map_prune.rs index 2cf0a4f7ba8..d76be3aedc8 100644 --- a/vortex-layout/benches/zone_map_prune.rs +++ b/vortex-layout/benches/zone_map_prune.rs @@ -24,11 +24,13 @@ use vortex_array::aggregate_fn::fns::max::Max; use vortex_array::aggregate_fn::fns::min::Min; use vortex_array::aggregate_fn::fns::nan_count::NanCount; use vortex_array::aggregate_fn::fns::null_count::NullCount; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::StructArray; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; +use vortex_array::dtype::session::DTypeSession; use vortex_array::expr::BoundExpression; use vortex_array::expr::Expression; use vortex_array::expr::eq; @@ -37,6 +39,11 @@ use vortex_array::expr::is_not_null; use vortex_array::expr::lit; use vortex_array::expr::or; use vortex_array::expr::root; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_layout::layouts::zoned::zone_map::ZoneMap; @@ -48,11 +55,21 @@ use vortex_utils::aliases::hash_map::HashMap; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } -static SESSION: LazyLock = - LazyLock::new(|| vortex_array::array_session().with::()); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); /// Zone counts to sweep. The small case exposes per-call fixed cost, the large case exposes /// per-zone evaluation cost. diff --git a/vortex-layout/examples/reverse_index/main.rs b/vortex-layout/examples/reverse_index/main.rs index e5f9e2a15d8..a03a16d2d20 100644 --- a/vortex-layout/examples/reverse_index/main.rs +++ b/vortex-layout/examples/reverse_index/main.rs @@ -28,7 +28,6 @@ use vortex_array::Canonical; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::StructArray; use vortex_array::arrays::VarBinViewArray; @@ -386,7 +385,7 @@ static DEMO_EDITION_DECLARATION: EditionDeclaration = EditionDeclaration { /// A session knowing the `vortex.indexed` layout and the reverse index. fn demo_session() -> VortexResult { - let session = array_session() + let session = VortexSession::empty() .with::() .with::() .with::(); diff --git a/vortex-layout/examples/reverse_index/pruning_tests.rs b/vortex-layout/examples/reverse_index/pruning_tests.rs index 04465b19580..cf09ed781aa 100644 --- a/vortex-layout/examples/reverse_index/pruning_tests.rs +++ b/vortex-layout/examples/reverse_index/pruning_tests.rs @@ -19,7 +19,6 @@ use object_store::memory::InMemory; use object_store::path::Path; use rstest::rstest; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::StructArray; use vortex_array::arrays::struct_::StructArrayExt; @@ -105,11 +104,11 @@ static INDEXED_TEST_DECLARATION: EditionDeclaration = EditionDeclaration { /// A session that can write and read the `vortex.indexed` layout, with a [`ReverseIndex`] /// registered as an index kind. /// -/// [`array_session`] already bundles everything [`vortex::VortexSessionDefault::default`] would -/// (arrays, dtypes, scalar functions, stats, optimizer kernels, aggregate functions, and memory); -/// this only adds the layout, runtime, and edition state that live in higher-level crates. +/// [`VortexSession::empty`] creates vortex-array's session variables (arrays, dtypes, scalar +/// functions, stats, optimizer kernels, aggregate functions, and memory) on first use; this only +/// adds the layout, runtime, and edition state that live in higher-level crates. fn session_with_indexed_layout() -> anyhow::Result { - let session = array_session() + let session = VortexSession::empty() .with::() .with::() .with::(); @@ -125,7 +124,7 @@ fn session_with_indexed_layout() -> anyhow::Result { /// registered — the fallback path `IndexedReader::plan_probe` takes when an index kind's spec /// goes unclaimed. fn session_without_reverse_index() -> VortexSession { - let session = array_session() + let session = VortexSession::empty() .with::() .with::() .with::(); diff --git a/vortex-layout/examples/reverse_index/tests.rs b/vortex-layout/examples/reverse_index/tests.rs index d5082be8a39..041973b782d 100644 --- a/vortex-layout/examples/reverse_index/tests.rs +++ b/vortex-layout/examples/reverse_index/tests.rs @@ -13,7 +13,6 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::MaskFuture; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::StructArray; use vortex_array::arrays::VarBinViewArray; @@ -111,7 +110,7 @@ static TEST_EDITION_DECLARATION: EditionDeclaration = EditionDeclaration { /// [`unregistered_index_kind_falls_back_to_the_data_child`] depends on two sessions with different /// index registries. fn session() -> VortexSession { - let session = array_session() + let session = VortexSession::empty() .with::() .with::() .with::(); diff --git a/vortex-layout/src/arrays/shared/tests.rs b/vortex-layout/src/arrays/shared/tests.rs index 2ed10e3b5f8..58c960124e2 100644 --- a/vortex-layout/src/arrays/shared/tests.rs +++ b/vortex-layout/src/arrays/shared/tests.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; @@ -10,17 +12,19 @@ use vortex_array::assert_arrays_eq; use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::arrays::shared::Shared; use crate::arrays::shared::SharedArrayExt; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn shared_array_caches_on_canonicalize() -> VortexResult<()> { let array = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable).into_array(); let shared = Shared::new(array); - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let first = shared.get_or_compute(|source| source.clone().execute::(&mut ctx))?; diff --git a/vortex-layout/src/layouts/dict/reader.rs b/vortex-layout/src/layouts/dict/reader.rs index 99b9d9ba613..90abc317c7d 100644 --- a/vortex-layout/src/layouts/dict/reader.rs +++ b/vortex-layout/src/layouts/dict/reader.rs @@ -356,6 +356,7 @@ impl LayoutReader for DictReader { #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use rstest::rstest; use vortex_array::ArrayContext; @@ -363,7 +364,6 @@ mod tests { use vortex_array::IntoArray as _; use vortex_array::MaskFuture; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::StructArray; use vortex_array::arrays::VarBinArray; @@ -410,10 +410,12 @@ mod tests { use crate::sequence::SequentialStreamExt; use crate::session::LayoutSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + // FIXME(ngates): Deprecate the global `runtime::single::block_on` helper and require tests // to call `block_on` on an explicit runtime instance. fn session_with_handle(handle: Handle) -> VortexSession { - array_session() + VortexSession::empty() .with::() .with::() .with_handle(handle) @@ -762,7 +764,7 @@ mod tests { outer: BoundExpression, inner: BoundExpression, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = VarBinArray::from_iter( [Some("abc"), Some("def"), None], DType::Utf8(Nullability::Nullable), diff --git a/vortex-layout/src/layouts/file_stats.rs b/vortex-layout/src/layouts/file_stats.rs index 3d031a65c7a..97669808eef 100644 --- a/vortex-layout/src/layouts/file_stats.rs +++ b/vortex-layout/src/layouts/file_stats.rs @@ -534,23 +534,27 @@ impl FileStatsAccumulator { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::bool::BoolArrayExt; use vortex_array::builders::VarBinViewBuilder; use vortex_buffer::BitBuffer; use vortex_buffer::buffer; + use vortex_session::VortexSession; use super::*; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case(DType::Utf8(Nullability::NonNullable))] #[case(DType::Binary(Nullability::NonNullable))] fn truncates_accumulated_stats(#[case] dtype: DType) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinViewBuilder::with_capacity_in( dtype.clone(), 2, @@ -608,7 +612,7 @@ mod tests { #[case(DType::Utf8(Nullability::NonNullable))] #[case(DType::Binary(Nullability::NonNullable))] fn truncated_accumulated_stats_are_inexact(#[case] dtype: DType) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut builder = VarBinViewBuilder::with_capacity_in( dtype, 2, @@ -630,7 +634,7 @@ mod tests { #[test] fn fixed_width_stats_omit_is_truncated_columns() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = buffer![0, 1, 2].into_array(); let mut acc = StatsAccumulator::new(array.dtype(), &[Stat::Max, Stat::Min, Stat::Sum], 12); acc.push_chunk(&array, &mut ctx) @@ -655,7 +659,7 @@ mod tests { #[case] chunks: Vec>>, #[case] expected: Option, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::I64, Nullability::Nullable); let mut acc = StatsAccumulator::new(&dtype, &[Stat::Sum], 12); for chunk in chunks { diff --git a/vortex-layout/src/layouts/flat/writer.rs b/vortex-layout/src/layouts/flat/writer.rs index b578b2e05ce..ac8bd44045a 100644 --- a/vortex-layout/src/layouts/flat/writer.rs +++ b/vortex-layout/src/layouts/flat/writer.rs @@ -179,7 +179,6 @@ mod tests { use vortex_array::IntoArray; use vortex_array::MaskFuture; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::StructArray; @@ -321,7 +320,7 @@ mod tests { #[test] fn struct_array_round_trip() { block_on(|handle| async { - let mut ctx_exec = array_session().create_execution_ctx(); + let mut ctx_exec = SESSION.create_execution_ctx(); let session = new_session().with_handle(handle); let mut validity_builder = BitBufferMut::with_capacity(2); validity_builder.append(true); diff --git a/vortex-layout/src/layouts/list/reader.rs b/vortex-layout/src/layouts/list/reader.rs index 837c5b7a396..fafa48346bd 100644 --- a/vortex-layout/src/layouts/list/reader.rs +++ b/vortex-layout/src/layouts/list/reader.rs @@ -622,7 +622,6 @@ mod tests { use rstest::rstest; use vortex_array::ArrayContext; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ListArray; use vortex_array::arrays::PrimitiveArray; @@ -637,6 +636,7 @@ mod tests { use vortex_buffer::buffer; use vortex_io::session::RuntimeSession; use vortex_io::session::RuntimeSessionExt; + use vortex_session::VortexSession; use super::*; use crate::LayoutRef; @@ -852,7 +852,7 @@ mod tests { } fn layout_test_session() -> VortexSession { - array_session() + VortexSession::empty() .with::() .with::() } @@ -888,7 +888,7 @@ mod tests { } fn create_basic_list_array(nullable: bool) -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let validity = if nullable { Validity::Array(BoolArray::from_iter([true, false, true]).into_array()) } else { @@ -906,7 +906,7 @@ mod tests { } fn create_six_list_array() -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let validity = Validity::Array( BoolArray::from_iter([true, false, true, false, true, true]).into_array(), ); @@ -991,7 +991,7 @@ mod tests { /// Build a list with 5 rows and lengths [2, 3, 0, 3, 2]. fn create_wider_list_array(nullable: bool) -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let validity = if nullable { Validity::Array(BoolArray::from_iter([true, true, false, true, true]).into_array()) } else { @@ -1093,7 +1093,7 @@ mod tests { #[tokio::test] async fn nested_list_propagates_element_splits() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let inner = ListArray::try_new( PrimitiveArray::from_iter(0..128_i32).into_array(), PrimitiveArray::from_iter((0..=8_u32).map(|idx| idx * 16)).into_array(), diff --git a/vortex-layout/src/layouts/list/writer.rs b/vortex-layout/src/layouts/list/writer.rs index 92195da2a31..8e3a25cf407 100644 --- a/vortex-layout/src/layouts/list/writer.rs +++ b/vortex-layout/src/layouts/list/writer.rs @@ -340,11 +340,12 @@ impl Matcher for AnyList { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use futures::stream; use rstest::rstest; use vortex_array::ArrayContext; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ListArray; @@ -354,6 +355,7 @@ mod tests { use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_io::session::RuntimeSession; + use vortex_session::VortexSession; use super::*; use crate::layouts::chunked::writer::ChunkedLayoutStrategy; @@ -364,8 +366,10 @@ mod tests { use crate::session::LayoutSession; use crate::test::FailingStrategy; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn layout_test_session() -> VortexSession { - array_session() + VortexSession::empty() .with::() .with::() .with_tokio() @@ -403,7 +407,7 @@ mod tests { } fn create_basic_list(validity: Validity) -> ArrayRef { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); ListArray::try_new( buffer![1i32, 2, 3, 4, 5].into_array(), buffer![0u32, 2, 5, 5].into_array(), @@ -485,7 +489,7 @@ mod tests { #[tokio::test] async fn list_of_struct_tree() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let struct_array = StructArray::from_fields( [ ("a", buffer![1i32, 2, 3, 4, 5].into_array()), @@ -520,7 +524,7 @@ mod tests { #[tokio::test] async fn list_of_list_tree() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let inner_list = ListArray::try_new( buffer![1i32, 2, 3, 4, 5, 6].into_array(), buffer![0u32, 2, 5, 5, 6].into_array(), @@ -551,7 +555,7 @@ mod tests { #[tokio::test] async fn list_of_list_of_list_tree() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let innermost = ListArray::try_new( buffer![1i32, 2, 3, 4].into_array(), buffer![0u32, 2, 4].into_array(), @@ -592,7 +596,7 @@ mod tests { #[tokio::test] async fn chunked_list_input_with_chunked_strategy_succeeds() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let chunk0 = ListArray::try_new( buffer![1i32, 2, 3].into_array(), buffer![0u32, 2, 3].into_array(), diff --git a/vortex-layout/src/layouts/repartition.rs b/vortex-layout/src/layouts/repartition.rs index d5bec2d6569..b213ddd7749 100644 --- a/vortex-layout/src/layouts/repartition.rs +++ b/vortex-layout/src/layouts/repartition.rs @@ -286,11 +286,11 @@ fn exact_size(chunk: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult { #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use vortex_array::ArrayContext; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::FixedSizeListArray; @@ -306,6 +306,7 @@ mod tests { use vortex_error::VortexResult; use vortex_io::runtime::single::block_on; use vortex_io::session::RuntimeSessionExt; + use vortex_session::VortexSession; use super::*; use crate::LayoutStrategy; @@ -317,6 +318,8 @@ mod tests { use crate::sequence::SequentialArrayStreamExt; use crate::test::new_session; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + const ONE_MEG: u64 = 1 << 20; #[test] @@ -562,7 +565,7 @@ mod tests { /// `pop_front` subtracted the larger Cached-era values. #[test] fn chunks_buffer_pop_front_no_panic_after_shared_execution() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let n = 20_000usize; let block_len = 10_000usize; diff --git a/vortex-layout/src/layouts/struct_/reader.rs b/vortex-layout/src/layouts/struct_/reader.rs index 877126b2632..7af98921eec 100644 --- a/vortex-layout/src/layouts/struct_/reader.rs +++ b/vortex-layout/src/layouts/struct_/reader.rs @@ -707,7 +707,6 @@ mod tests { use vortex_array::IntoArray; use vortex_array::MaskFuture; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::StructArray; @@ -1002,7 +1001,7 @@ mod tests { fn test_struct_layout_select( #[from(struct_layout)] (segments, layout): (Arc, LayoutRef), ) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let reader = layout .new_reader("".into(), segments, &SESSION, &Default::default()) .unwrap(); @@ -1110,7 +1109,7 @@ mod tests { // ...and the result is masked with the validity of the parent StructArray assert_eq!( result - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap(), Scalar::null(result.dtype().clone()), ); @@ -1675,7 +1674,7 @@ mod tests { // Row 0: struct is valid, field "c" is 4. assert_eq!( result - .execute_scalar(0, &mut array_session().create_execution_ctx()) + .execute_scalar(0, &mut SESSION.create_execution_ctx()) .unwrap() .as_struct() .field_by_idx(0) @@ -1686,7 +1685,7 @@ mod tests { // Row 1: struct is null (because root.a.b was null at this row). assert!( result - .execute_scalar(1, &mut array_session().create_execution_ctx()) + .execute_scalar(1, &mut SESSION.create_execution_ctx()) .unwrap() .as_struct() .is_null() @@ -1695,7 +1694,7 @@ mod tests { // Row 2: struct is valid, field "c" is 6. assert_eq!( result - .execute_scalar(2, &mut array_session().create_execution_ctx()) + .execute_scalar(2, &mut SESSION.create_execution_ctx()) .unwrap() .as_struct() .field_by_idx(0) diff --git a/vortex-layout/src/layouts/table.rs b/vortex-layout/src/layouts/table.rs index 5040f39187d..00853638e44 100644 --- a/vortex-layout/src/layouts/table.rs +++ b/vortex-layout/src/layouts/table.rs @@ -322,7 +322,6 @@ mod tests { use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ListArray; @@ -409,7 +408,7 @@ mod tests { /// `elements` are decomposed as a nested `ListLayout`. #[tokio::test] async fn dispatches_nested_list() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let inner = ListArray::try_new( buffer![1i32, 2, 3, 4, 5, 6].into_array(), buffer![0u32, 2, 5, 5, 6].into_array(), @@ -440,7 +439,7 @@ mod tests { /// decomposition for the elements, and a nullable list writes a validity child. #[tokio::test] async fn dispatches_struct_list_struct() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let inner_struct = StructArray::from_fields( [ ("a", buffer![1i32, 2, 3, 4, 5].into_array()), @@ -476,7 +475,7 @@ mod tests { /// This is the "list-of-chunkeds" topology top-level decomposition unlocks. #[tokio::test] async fn dispatches_chunked_list() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let chunk0 = ListArray::try_new( buffer![1i32, 2, 3].into_array(), buffer![0u32, 2, 3].into_array(), @@ -516,7 +515,7 @@ mod tests { /// A wrapper can repartition and zone lists in outer-row space before decomposition. #[tokio::test] async fn wraps_list_strategy_before_decomposition() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let list = ListArray::try_new( PrimitiveArray::from_iter(0..9_i32).into_array(), PrimitiveArray::from_iter(0..=9_u32).into_array(), diff --git a/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/mod.rs b/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/mod.rs index 3986f092ac6..a13118c5729 100644 --- a/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/mod.rs +++ b/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/mod.rs @@ -426,7 +426,7 @@ pub(in crate::layouts::zoned::aggregates::bloom_filter) mod test_utils { use super::*; pub fn setup() -> VortexResult { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); let options = BloomOptions::default(); let metadata = BloomFilter .serialize(&options)? diff --git a/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/scalar_fn.rs b/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/scalar_fn.rs index 4cb35e150d5..7896ba411c5 100644 --- a/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/scalar_fn.rs +++ b/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/scalar_fn.rs @@ -280,12 +280,12 @@ impl StatsRewriteRule for BloomEqRewrite { #[cfg(test)] mod tests { use std::sync::Arc; + use std::sync::LazyLock; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::aggregate_fn::AggregateFnVTableExt; use vortex_array::aggregate_fn::session::AggregateFnSessionExt; - use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::ScalarFnArray; @@ -318,6 +318,8 @@ mod tests { use crate::layouts::zoned::aggregates::bloom_filter::scalar_fn::BloomEqRewrite; use crate::layouts::zoned::zone_map::ZoneMap; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn register(session: &VortexSession, options: BloomOptions) { session.aggregate_fns().register(BloomFilter); session.scalar_fns().register(BloomContains); @@ -336,7 +338,7 @@ mod tests { fn bloom_rule_prunes_ok() -> VortexResult<()> { let options = BloomOptions::default(); let aggregate_fn = BloomFilter.bind(options.clone()); - let session = array_session(); + let session = VortexSession::empty(); register(&session, options.clone()); let filters = VarBinViewArray::from_iter_nullable_bin([ @@ -373,7 +375,7 @@ mod tests { #[test] fn bloom_rule_is_inconclusive_for_nulls() -> VortexResult<()> { let dtype = DType::Primitive(PType::I64, Nullability::Nullable); - let session = array_session(); + let session = VortexSession::empty(); let rule = BloomEqRewrite { options: BloomOptions::default(), }; @@ -389,7 +391,7 @@ mod tests { #[test] fn missing_bloom_stat_stays_inconclusive() -> VortexResult<()> { let options = BloomOptions::default(); - let session = array_session(); + let session = VortexSession::empty(); register(&session, options); let dtype = DType::Primitive(PType::I64, Nullability::NonNullable); @@ -416,7 +418,7 @@ mod tests { VarBinViewArray::from_iter_bin([b"not a bloom filter".as_slice()]).into_array(); let needle = ConstantArray::new(42i64, 1).into_array(); let args = VecExecutionArgs::new(vec![filters, needle], 1); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = BloomContains .execute(&options, &args, &mut ctx) @@ -440,7 +442,7 @@ mod tests { let filters = VarBinViewArray::from_iter_bin([vec![0; 32]]).into_array(); let needle = ConstantArray::new(42i64, 1).into_array(); let args = VecExecutionArgs::new(vec![filters, needle], 1); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = BloomContains .execute(&options, &args, &mut ctx) @@ -462,7 +464,7 @@ mod tests { ) .into_array(); let args = VecExecutionArgs::new(vec![filters, needle], 1); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = BloomContains.execute(&options, &args, &mut ctx)?; assert_arrays_eq!(actual, BoolArray::from_iter([None::]), &mut ctx); @@ -479,7 +481,7 @@ mod tests { .into_array(); let needle = ConstantArray::new(Scalar::primitive(42_i64, Nullability::Nullable), 1).into_array(); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let planned = ScalarFnArray::try_new(BloomContains.bind(options), [filters, needle])?; assert_arrays_eq!(planned, BoolArray::from_iter([Some(true)]), &mut ctx); @@ -503,7 +505,7 @@ mod tests { ) .into_array(); let args = VecExecutionArgs::new(vec![filters, needle], 1); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let error = BloomContains .execute(&options, &args, &mut ctx) @@ -528,7 +530,7 @@ mod tests { let needle = ConstantArray::new(42i64, 2).into_array(); let args = VecExecutionArgs::new(vec![filters, needle], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = BloomContains.execute(&options, &args, &mut ctx)?; assert_arrays_eq!(actual, BoolArray::from_iter([None::, None]), &mut ctx); @@ -551,7 +553,7 @@ mod tests { .into_array(); let needle = ConstantArray::new(42i64, 3).into_array(); let args = VecExecutionArgs::new(vec![filters, needle], 3); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = BloomContains.execute(&options, &args, &mut ctx)?; assert_arrays_eq!( @@ -578,7 +580,7 @@ mod tests { let needle = ConstantArray::new(42i64, 2).into_array(); let args = VecExecutionArgs::new(vec![filters, needle], 2); - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let actual = BloomContains.execute(&options, &args, &mut ctx)?; assert_arrays_eq!( diff --git a/vortex-layout/src/layouts/zoned/mod.rs b/vortex-layout/src/layouts/zoned/mod.rs index 58103b63feb..ff6aaba350b 100644 --- a/vortex-layout/src/layouts/zoned/mod.rs +++ b/vortex-layout/src/layouts/zoned/mod.rs @@ -507,6 +507,8 @@ impl SerializeMetadata for LegacyStatsMetadata { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::aggregate_fn::AggregateFnRef; use vortex_array::aggregate_fn::AggregateFnVTableExt; @@ -531,6 +533,8 @@ mod tests { use crate::layouts::zoned::aggregates::bloom_filter::BloomOptions; use crate::segments::SegmentId; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn aggregate_spec(aggregate_fn: AggregateFnRef) -> AggregateSpecProto { AggregateSpecProto::try_from_aggregate_fn(&aggregate_fn).unwrap() } @@ -634,10 +638,9 @@ mod tests { ) .into_layout(), ]); - let session = vortex_array::array_session(); let build_read_ctx = ReadContext::new([]); let build_ctx = LayoutBuildContext { - session: &session, + session: &SESSION, array_read_ctx: &build_read_ctx, }; @@ -665,10 +668,9 @@ mod tests { aggregate_specs: Arc::new([]), }; let children = OwnedLayoutChildren::layout_children(vec![]); - let session = vortex_array::array_session(); let build_read_ctx = ReadContext::new([]); let build_ctx = LayoutBuildContext { - session: &session, + session: &SESSION, array_read_ctx: &build_read_ctx, }; @@ -693,7 +695,7 @@ mod tests { FlatLayout::new(0, dtype.clone(), SegmentId::from(0), read_ctx.clone()).into_layout(), FlatLayout::new(0, dtype.clone(), SegmentId::from(1), read_ctx).into_layout(), ]); - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.allow_unknown(); let build_read_ctx = ReadContext::new([]); let build_ctx = LayoutBuildContext { @@ -730,10 +732,9 @@ mod tests { FlatLayout::new(0, dtype.clone(), SegmentId::from(0), read_ctx.clone()).into_layout(), FlatLayout::new(0, dtype.clone(), SegmentId::from(1), read_ctx).into_layout(), ]); - let session = vortex_array::array_session(); let build_read_ctx = ReadContext::new([]); let build_ctx = LayoutBuildContext { - session: &session, + session: &SESSION, array_read_ctx: &build_read_ctx, }; diff --git a/vortex-layout/src/layouts/zoned/reader.rs b/vortex-layout/src/layouts/zoned/reader.rs index 215ba3455ed..46f1d229c46 100644 --- a/vortex-layout/src/layouts/zoned/reader.rs +++ b/vortex-layout/src/layouts/zoned/reader.rs @@ -246,6 +246,7 @@ impl LayoutReader for ZonedReader { mod test { use std::num::NonZeroUsize; use std::sync::Arc; + use std::sync::LazyLock; use rstest::fixture; use rstest::rstest; @@ -253,7 +254,6 @@ mod test { use vortex_array::IntoArray; use vortex_array::MaskFuture; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::PrimitiveArray; use vortex_array::assert_arrays_eq; @@ -294,8 +294,10 @@ mod test { use crate::sequence::SequentialArrayStreamExt; use crate::session::LayoutSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn session_with_handle(handle: Handle) -> VortexSession { - array_session() + VortexSession::empty() .with::() .with::() .with_handle(handle) @@ -339,7 +341,7 @@ mod test { #[from(stats_layout)] (segments, layout): (Arc, LayoutRef), ) { block_on(|handle| async { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let session = session_with_handle(handle); let reader = layout .new_reader("".into(), segments, &session, &Default::default()) @@ -476,7 +478,7 @@ mod test { .slot(1)? .vortex_expect("ZonedLayout always has a stats child"), ]); - let session = array_session(); + let session = VortexSession::empty(); let read_ctx = ReadContext::new([]); let build_ctx = LayoutBuildContext { session: &session, @@ -521,7 +523,7 @@ mod test { MaskFuture::new_true(row_count.try_into().unwrap()), )? .await?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!( projected, buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9].into_array(), diff --git a/vortex-layout/src/layouts/zoned/schema.rs b/vortex-layout/src/layouts/zoned/schema.rs index f90d40bbe3d..0e4d9db318a 100644 --- a/vortex-layout/src/layouts/zoned/schema.rs +++ b/vortex-layout/src/layouts/zoned/schema.rs @@ -239,6 +239,8 @@ pub(crate) fn default_bounded_stat_max_bytes() -> std::num::NonZeroUsize { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::aggregate_fn::AggregateFnVTableExt; use vortex_array::aggregate_fn::NumericalAggregateOpts; use vortex_array::aggregate_fn::fns::max::Max; @@ -252,16 +254,17 @@ mod tests { use super::*; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn unknown_aggregate_errors_without_allow_unknown() { - let session = vortex_array::array_session(); let specs = [AggregateSpecProto::new_unknown("vortex.test.unknown")]; - assert!(try_aggregate_fns_from_specs(&specs, &session).is_err()); + assert!(try_aggregate_fns_from_specs(&specs, &SESSION).is_err()); } #[test] fn unknown_aggregate_is_none_with_allow_unknown() -> VortexResult<()> { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); session.allow_unknown(); let specs = [AggregateSpecProto::new_unknown("vortex.test.unknown")]; assert!(try_aggregate_fns_from_specs(&specs, &session)?.is_none()); diff --git a/vortex-layout/src/layouts/zoned/writer.rs b/vortex-layout/src/layouts/zoned/writer.rs index 9baca24d18f..6326f1b05eb 100644 --- a/vortex-layout/src/layouts/zoned/writer.rs +++ b/vortex-layout/src/layouts/zoned/writer.rs @@ -249,6 +249,8 @@ fn default_zoned_aggregate_fns(dtype: &DType, session: &VortexSession) -> Arc<[A #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayContext; use vortex_array::IntoArray; @@ -280,6 +282,8 @@ mod tests { use crate::sequence::SequentialArrayStreamExt; use crate::session::LayoutSession; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Write three zones of primitives through `ctx`, returning the aggregates the zoned /// layout recorded. fn write_zones(ctx: LayoutWriterContext) -> VortexResult> { @@ -312,7 +316,7 @@ mod tests { .sequenced(ptr); block_on(|handle: Handle| async move { - let session = vortex_array::array_session() + let session = VortexSession::empty() .with::() .with::() .with_handle(handle); @@ -372,10 +376,8 @@ mod tests { #[test] fn default_aggregates_bound_variable_length_min_max() { - let aggregate_fns = default_zoned_aggregate_fns( - &DType::Utf8(Nullability::NonNullable), - &vortex_array::array_session(), - ); + let aggregate_fns = + default_zoned_aggregate_fns(&DType::Utf8(Nullability::NonNullable), &SESSION); assert_eq!( aggregate_fns[0].as_::().max_bytes, @@ -389,8 +391,7 @@ mod tests { #[test] fn default_aggregates_keep_fixed_width_min_max_exact() { - let aggregate_fns = - default_zoned_aggregate_fns(&PType::I32.into(), &vortex_array::array_session()); + let aggregate_fns = default_zoned_aggregate_fns(&PType::I32.into(), &SESSION); assert!(aggregate_fns[0].is::()); assert!(aggregate_fns[1].is::()); @@ -404,7 +405,7 @@ mod tests { Timestamp::new(TimeUnit::Microseconds, Nullability::Nullable).erased(), ))] fn default_aggregates_never_record_sum(#[case] dtype: DType) { - let aggregate_fns = default_zoned_aggregate_fns(&dtype, &vortex_array::array_session()); + let aggregate_fns = default_zoned_aggregate_fns(&dtype, &VortexSession::empty()); assert!( aggregate_fns diff --git a/vortex-layout/src/plan/physical/tests.rs b/vortex-layout/src/plan/physical/tests.rs index 44705753b3e..0557bc30df8 100644 --- a/vortex-layout/src/plan/physical/tests.rs +++ b/vortex-layout/src/plan/physical/tests.rs @@ -38,6 +38,7 @@ use vortex_array::stats::as_stat_bitset_bytes; use vortex_error::VortexResult; use vortex_error::vortex_err; use vortex_mask::Mask; +use vortex_session::VortexSession; use vortex_session::registry::CachedId; use vortex_session::registry::ReadContext; @@ -1269,7 +1270,7 @@ fn stats_expression_rewrites_to_zoned_pruning_plan() -> VortexResult<()> { vec![max].into(), )? .into_layout(); - let session = vortex_array::array_session(); + let session = VortexSession::empty(); let filter = gt(root(), lit(5_i32)); let falsifier = filter .bind(&dtype)? @@ -1347,7 +1348,7 @@ fn pruning_expression_partitions_across_row_idx_and_zoned_struct_field() -> Vort ) .into_layout(); let source = make_plan(layout)?; - let session = vortex_array::array_session(); + let session = VortexSession::empty(); let filter = and( gt(row_idx(), lit(11_u64)), gt(get_item("a", root()), lit(5_i32)), @@ -1382,7 +1383,7 @@ fn legacy_layout( flat(5, dtype.clone(), 0), flat(2, zones_dtype, 1), ]); - let session = vortex_array::array_session(); + let session = VortexSession::empty(); let read_ctx = ReadContext::new([]); let build_ctx = LayoutBuildContext { session: &session, diff --git a/vortex-layout/src/scan/scan_builder.rs b/vortex-layout/src/scan/scan_builder.rs index 9551f9fbd1d..f8f803adb94 100644 --- a/vortex-layout/src/scan/scan_builder.rs +++ b/vortex-layout/src/scan/scan_builder.rs @@ -468,6 +468,7 @@ mod test { use std::ops::Range; use std::pin::Pin; use std::sync::Arc; + use std::sync::LazyLock; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; use std::sync::mpsc; @@ -483,7 +484,6 @@ mod test { use vortex_array::IntoArray; use vortex_array::MaskFuture; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::DType; use vortex_array::dtype::FieldMask; @@ -512,6 +512,7 @@ mod test { use vortex_io::runtime::single::SingleThreadRuntime; use vortex_io::runtime::tokio::TokioRuntime; use vortex_mask::Mask; + use vortex_session::VortexSession; use super::ScanBuilder; use super::referenced_field_masks; @@ -528,6 +529,8 @@ mod test { use crate::scan::test::keep_odd; use crate::scan::test::session_with_handle; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn nested_dtype() -> DType { DType::Struct( StructFields::from_iter([ @@ -816,7 +819,7 @@ mod test { #[test] fn into_stream_executes_after_prepare() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let calls = Arc::new(AtomicUsize::new(0)); let reader = Arc::new(SplittingLayoutReader::new(Arc::clone(&calls))); @@ -840,7 +843,7 @@ mod test { #[test] fn supplied_natural_splits_skip_layout_walk() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let calls = Arc::new(AtomicUsize::new(0)); let reader = Arc::new(SplittingLayoutReader::new(Arc::clone(&calls))); @@ -1308,7 +1311,7 @@ mod test { #[test] fn into_stream_with_row_range() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let calls = Arc::new(AtomicUsize::new(0)); let reader = Arc::new(SplittingLayoutReader::new(Arc::clone(&calls))); diff --git a/vortex-layout/src/scan/test.rs b/vortex-layout/src/scan/test.rs index 749f2e45e20..7d030f2c987 100644 --- a/vortex-layout/src/scan/test.rs +++ b/vortex-layout/src/scan/test.rs @@ -11,7 +11,6 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::MaskFuture; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::DType; use vortex_array::dtype::FieldMask; @@ -34,8 +33,10 @@ use crate::RowSplits; use crate::SplitRange; use crate::session::LayoutSession; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + pub fn new_session() -> VortexSession { - array_session() + VortexSession::empty() .with::() .with::() } @@ -249,7 +250,7 @@ pub fn collect_scan_values(iter: I) -> VortexResult> where I: IntoIterator>, { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let mut values = Vec::new(); for chunk in iter { let primitive = chunk?.execute::(&mut ctx)?; diff --git a/vortex-layout/src/scan/v2/tests.rs b/vortex-layout/src/scan/v2/tests.rs index ba29376bafb..29fbcf22d11 100644 --- a/vortex-layout/src/scan/v2/tests.rs +++ b/vortex-layout/src/scan/v2/tests.rs @@ -4,6 +4,7 @@ use std::num::NonZeroUsize; use std::ops::Range; use std::sync::Arc; +use std::sync::LazyLock; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; use std::time::Duration; @@ -20,7 +21,6 @@ use vortex_array::ArrayContext; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ListArray; use vortex_array::arrays::PrimitiveArray; @@ -76,13 +76,15 @@ use crate::sequence::SequentialStreamAdapter; use crate::sequence::SequentialStreamExt as _; use crate::test::new_session; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + const CHUNK_ROWS: usize = 1000; const CHUNKS: usize = 4; /// A table chunk of `CHUNK_ROWS` rows starting at row `start`: an integer, a nullable string and a /// list column. fn table_chunk(start: usize) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let rows = start..start + CHUNK_ROWS; let ints = Buffer::from_iter( rows.clone() diff --git a/vortex-layout/src/serde.rs b/vortex-layout/src/serde.rs index 0995a7535cd..0c67f7dd681 100644 --- a/vortex-layout/src/serde.rs +++ b/vortex-layout/src/serde.rs @@ -223,10 +223,12 @@ impl WriteFlatBuffer for LayoutFlatBufferWriter<'_> { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use flatbuffers::FlatBufferBuilder; - use vortex_array::array_session; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; + use vortex_session::VortexSession; use vortex_session::registry::ReadContext; use super::layout_from_flatbuffer_with_options; @@ -234,6 +236,9 @@ mod tests { use crate::flatbuffers::layout as fbl; use crate::session::LayoutSession; + static SESSION: LazyLock = + LazyLock::new(|| VortexSession::empty().with::()); + #[expect(clippy::disallowed_methods, reason = "test-only id")] #[test] fn unknown_layout_encoding_allow_unknown() { @@ -275,14 +280,13 @@ mod tests { LayoutEncodingId::new("vortex.test.foreign_child_layout"), ]); let array_ctx = ReadContext::new([]); - let session = array_session().with::(); let layout = layout_from_flatbuffer_with_options( layout_buffer, &DType::Variant(Nullability::Nullable), &layout_ctx, &array_ctx, - &session, + &SESSION, true, ) .unwrap(); diff --git a/vortex-layout/src/test.rs b/vortex-layout/src/test.rs index ecf773246da..29eeb8c3eba 100644 --- a/vortex-layout/src/test.rs +++ b/vortex-layout/src/test.rs @@ -12,7 +12,7 @@ use crate::session::LayoutSession; pub static SESSION: LazyLock = LazyLock::new(|| new_session().with_tokio()); pub fn new_session() -> VortexSession { - vortex_array::array_session() + VortexSession::empty() .with::() .with::() } diff --git a/vortex-python/src/arrays/range_to_sequence.rs b/vortex-python/src/arrays/range_to_sequence.rs index da1a07d9900..c8804c565a4 100644 --- a/vortex-python/src/arrays/range_to_sequence.rs +++ b/vortex-python/src/arrays/range_to_sequence.rs @@ -89,6 +89,8 @@ fn range_len(start: isize, stop: isize, step: isize) -> Option { #[cfg(test)] mod test { + use std::sync::LazyLock; + use rstest::rstest; use vortex::array::IntoArray as _; use vortex::array::assert_arrays_eq; @@ -98,13 +100,15 @@ mod test { use vortex::dtype::Nullability; use vortex::dtype::PType; use vortex::error::VortexResult; + use vortex::session::VortexSession; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use crate::arrays::range_to_sequence::range_len; use crate::arrays::range_to_sequence::range_ptype; use crate::arrays::range_to_sequence::sequence_array_from_range; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Python's `range` is empty in three shapes, and `range_len` reports the first as `Some(0)` /// and the other two as `None`. All three must convert to an empty array. #[rstest] @@ -143,7 +147,7 @@ mod test { #[test] fn descending_range_above_zero_converts() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ptype = range_ptype(5, 1, -1); let dtype = DType::Primitive(ptype, Nullability::NonNullable); let arr = match_each_integer_ptype!(ptype, |T| { @@ -169,7 +173,7 @@ mod test { #[test] fn test_sequence_array_from_len() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DType::Primitive(PType::U16, Nullability::NonNullable); let arr = sequence_array_from_range::(0, 10, 1, dtype).unwrap(); assert_arrays_eq!( diff --git a/vortex-row/benches/row_encode.rs b/vortex-row/benches/row_encode.rs index 9e173870ab8..66b69cf16d1 100644 --- a/vortex-row/benches/row_encode.rs +++ b/vortex-row/benches/row_encode.rs @@ -36,12 +36,18 @@ use rand::distr::Alphanumeric; use rand::rngs::StdRng; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::PrimitiveArray; use vortex_array::arrays::StructArray; use vortex_array::arrays::VarBinViewArray; use vortex_array::arrays::listview::ListViewArray; use vortex_array::arrays::listview::ListViewArraySlotsExt; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_row::RowEncoder; use vortex_session::VortexSession; @@ -53,7 +59,16 @@ static GLOBAL: MiMalloc = MiMalloc; const N: usize = 1_000; const LIST_LEN: usize = 8; -static SESSION: LazyLock = LazyLock::new(array_session); +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); fn main() { LazyLock::force(&SESSION); diff --git a/vortex-row/src/encoder.rs b/vortex-row/src/encoder.rs index b725cbd34c8..1346d8ffc7e 100644 --- a/vortex-row/src/encoder.rs +++ b/vortex-row/src/encoder.rs @@ -28,12 +28,13 @@ use crate::size::RowSize; /// # Example /// /// ```rust -/// use vortex_array::{IntoArray, VortexSessionExecute, array_session}; +/// use vortex_array::{IntoArray, VortexSessionExecute}; +/// use vortex_session::VortexSession; /// use vortex_array::arrays::PrimitiveArray; /// use vortex_row::{RowEncoder, RowSortField}; /// /// # fn example() -> vortex_error::VortexResult<()> { -/// let mut ctx = array_session().create_execution_ctx(); +/// let mut ctx = VortexSession::empty().create_execution_ctx(); /// let ids = PrimitiveArray::from_iter([3i32, 1, 2]).into_array(); /// let scores = PrimitiveArray::from_iter([10i32, 20, 10]).into_array(); /// diff --git a/vortex-row/src/tests.rs b/vortex-row/src/tests.rs index d5d1d168d88..ea1ae1fec38 100644 --- a/vortex-row/src/tests.rs +++ b/vortex-row/src/tests.rs @@ -5,11 +5,11 @@ use std::cmp::Ordering; use std::f64::consts::PI; +use std::sync::LazyLock; use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::BoolArray; use vortex_array::arrays::DecimalArray; use vortex_array::arrays::ExtensionArray; @@ -33,6 +33,7 @@ use vortex_array::extension::datetime::TimeUnit; use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; +use vortex_session::VortexSession; use crate::RowEncoder; use crate::RowEncodingOptions; @@ -41,8 +42,10 @@ use crate::compute_row_sizes_with_options; use crate::convert_columns; use crate::convert_columns_with_options; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn collect_row_bytes(array: &ListViewArray) -> Vec> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_eq!( array.dtype(), &DType::list( @@ -70,7 +73,7 @@ fn assert_row_order(rows: &[Vec], len: usize, compare: impl Fn(usize, usize) } fn assert_sort_order_i64(values: Vec, descending: bool) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let col = PrimitiveArray::from_iter(values.clone()).into_array(); let field = RowSortField::new(descending, true); let encoded = convert_columns(&[col], &[field], &mut ctx)?; @@ -96,7 +99,7 @@ fn primitive_i64_roundtrip(#[case] descending: bool) -> VortexResult<()> { #[test] fn primitive_u32_sort_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values: Vec = vec![0, 1, 100, u32::MAX, 42, 17]; let col = PrimitiveArray::from_iter(values.clone()).into_array(); let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?; @@ -108,7 +111,7 @@ fn primitive_u32_sort_order() -> VortexResult<()> { #[test] fn reject_temporal_extension_dtype_early() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let storage = PrimitiveArray::from_iter([2i32, -1, 0, 7]).into_array(); let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable).erased(); let col = ExtensionArray::new(ext_dtype, storage).into_array(); @@ -124,7 +127,7 @@ fn reject_temporal_extension_dtype_early() -> VortexResult<()> { #[test] fn reject_nested_temporal_extension_dtype_early() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let storage = PrimitiveArray::from_iter([2i32, -1, 0, 7]).into_array(); let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable).erased(); let date_col = ExtensionArray::new(ext_dtype, storage).into_array(); @@ -143,7 +146,7 @@ fn reject_nested_temporal_extension_dtype_early() -> VortexResult<()> { #[test] fn primitive_f64_sort_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // We use IEEE total-ordering semantics: -0.0 < +0.0 in the byte encoding (matches // `arrow-row`). Avoid -0.0 in the natural-order baseline since partial_cmp says // -0.0 == 0.0. @@ -160,7 +163,7 @@ fn primitive_f64_sort_order() -> VortexResult<()> { #[test] fn bool_sort_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let col = BoolArray::from_iter([true, false, true, false]).into_array(); let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?; let rows = collect_row_bytes(&encoded); @@ -172,7 +175,7 @@ fn bool_sort_order() -> VortexResult<()> { #[test] fn utf8_sort_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values = vec![ "banana", "apple", @@ -191,7 +194,7 @@ fn utf8_sort_order() -> VortexResult<()> { #[test] fn multi_column_sort() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ints: Vec = vec![1, 2, 1, 2, 1, 3]; let strs = vec!["b", "a", "a", "b", "c", "z"]; let col0 = PrimitiveArray::from_iter(ints.clone()).into_array(); @@ -211,7 +214,7 @@ fn multi_column_sort() -> VortexResult<()> { #[test] fn nulls_first_and_last() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values: Vec> = vec![Some(5), None, Some(1), None, Some(3)]; let col = PrimitiveArray::from_option_iter(values.clone()).into_array(); @@ -252,7 +255,7 @@ fn nulls_first_and_last() -> VortexResult<()> { #[test] fn reusable_options_helpers() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let options = RowEncodingOptions::new([RowSortField::descending().nulls_last()]); assert_eq!(options.len(), 1); assert!(!options.is_empty()); @@ -293,7 +296,7 @@ fn reusable_options_helpers() -> VortexResult<()> { #[test] fn row_encoder_new_accepts_sort_fields() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let encoder = RowEncoder::new([RowSortField::ascending()]); let col = PrimitiveArray::from_iter([1i32, 2, 3]).into_array(); @@ -311,7 +314,7 @@ fn row_encoder_new_accepts_sort_fields() -> VortexResult<()> { #[test] fn default_row_encoder_uses_default_fields() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let col0 = PrimitiveArray::from_iter([1i32, 2, 3]).into_array(); let col1 = PrimitiveArray::from_iter([4i32, 5, 6]).into_array(); @@ -330,7 +333,7 @@ fn default_row_encoder_uses_default_fields() -> VortexResult<()> { #[test] fn struct_sort_order() -> VortexResult<()> { use vortex_array::arrays::StructArray; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ids: Vec = vec![3, 1, 3, 1, 2]; let names = vec!["b", "a", "a", "b", "z"]; let id_arr = PrimitiveArray::from_iter(ids.clone()).into_array(); @@ -354,7 +357,7 @@ fn row_size_struct_shape() -> VortexResult<()> { use crate::compute_row_sizes; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ints: Vec = vec![1, 2, 3, 4, 5]; let strs = vec!["a", "bb", "ccc", "", "eeeee"]; let col0 = PrimitiveArray::from_iter(ints).into_array(); @@ -402,7 +405,7 @@ fn row_size_struct_shape() -> VortexResult<()> { #[test] fn single_buffer_invariant() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Encoded rows here are all > 12 bytes, forcing the Ref-view path that points back into // the shared data buffer. let nrows = 64usize; @@ -446,7 +449,7 @@ fn single_buffer_invariant() -> VortexResult<()> { /// boundaries always align. #[test] fn multi_column_varlen_empty_vs_nul_byte_string() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // col1: empty vs single 0-byte. col2: same int for all rows. let col1 = VarBinViewArray::from_iter_str(["", "\0", "a", "ab"]).into_array(); let col2 = PrimitiveArray::from_iter([1i32, 1, 1, 1]).into_array(); @@ -479,7 +482,7 @@ fn multi_column_varlen_empty_vs_nul_byte_string() -> VortexResult<()> { /// the 3-sentinel scheme null=0x00, empty=0x01 differ at byte 0. #[test] fn multi_column_varlen_null_vs_empty() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let col1 = VarBinViewArray::from_iter_nullable_str([ None::<&str>, Some(""), @@ -544,7 +547,7 @@ fn multi_column_varlen_null_vs_empty() -> VortexResult<()> { /// non-empty's first byte is smaller than empty's first byte. #[test] fn varlen_descending_empty_vs_non_empty() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let col = VarBinViewArray::from_iter_str(["a", "", "abc"]).into_array(); let encoded = convert_columns(&[col], &[RowSortField::descending()], &mut ctx)?; let rows = collect_row_bytes(&encoded); @@ -565,7 +568,7 @@ fn null_struct_rows_with_varying_child_lengths_are_byte_equal() -> VortexResult< use vortex_array::validity::Validity; use vortex_buffer::BitBuffer; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Build a nullable struct{name: utf8} where rows 0 and 2 are null but the underlying // child has different length data ("short" vs "much longer text data"). let names = @@ -590,7 +593,7 @@ fn null_struct_rows_with_varying_child_lengths_are_byte_equal() -> VortexResult< #[test] fn primitive_f32_sort_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values: Vec = vec![-1.5, 0.0, 1.5, f32::INFINITY, f32::NEG_INFINITY]; let col = PrimitiveArray::from_iter(values.clone()).into_array(); let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?; @@ -604,7 +607,7 @@ fn primitive_f32_sort_order() -> VortexResult<()> { #[test] fn primitive_f16_sort_order() -> VortexResult<()> { use vortex_array::dtype::half::f16; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let values: Vec = vec![ f16::from_f32(-1.5), f16::from_f32(0.0), @@ -631,7 +634,7 @@ fn variable_list_sort_order( #[case] field: RowSortField, #[case] expected_indices: Vec, ) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // [[1, 2], [1], [], [2], null, [1, 3]] let elements = PrimitiveArray::from_iter([1i32, 2, 2, 1, 3]).into_array(); let offsets = buffer![0u32, 0, 0, 2, 0, 3].into_array(); @@ -656,7 +659,7 @@ fn variable_list_sort_order( #[test] fn variable_list_prefix_order_precedes_following_column() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // The second column deliberately has the opposite order. The list terminator must decide // [1] < [1, 2] before comparison can observe that following column. let lists = ListViewArray::new( @@ -681,7 +684,7 @@ fn variable_list_prefix_order_precedes_following_column() -> VortexResult<()> { #[test] fn variable_list_null_element_prefix_precedes_following_column() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // The child null sentinel and ascending list terminator are both zero. // The element marker must decide the list prefix before the following column. let mut lists = ListViewArray::new( @@ -729,7 +732,7 @@ fn variable_list_null_element_prefix_precedes_following_column() -> VortexResult #[test] fn map_sort_order() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let map_dtype = MapDType::try_new( DType::Primitive(PType::I32, Nullability::NonNullable), DType::Primitive(PType::I32, Nullability::NonNullable), @@ -769,7 +772,7 @@ fn map_sort_order() -> VortexResult<()> { #[case::ascending(false)] #[case::descending(true)] fn decimal_keys_comparable_across_chunk_widths(#[case] descending: bool) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(7, 5); let field = RowSortField::new(descending, true); @@ -802,7 +805,7 @@ fn decimal_keys_comparable_across_chunk_widths(#[case] descending: bool) -> Vort /// encoding must ignore it rather than report a spurious overflow. #[test] fn decimal_null_slot_garbage_does_not_error() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(7, 5); let field = RowSortField::new(false, true); @@ -824,7 +827,7 @@ fn decimal_null_slot_garbage_does_not_error() -> VortexResult<()> { /// silently encoding a corrupt key. #[test] fn decimal_value_not_fitting_key_width_errors() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(7, 5); let field = RowSortField::new(false, true); @@ -841,7 +844,7 @@ fn decimal_value_not_fitting_key_width_errors() { #[test] fn decimal256_keys_preserve_order_and_physical_width_independence() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = DecimalDType::new(76, 4); let large = i256::from_parts(0, 1 << 100); let values = [ diff --git a/vortex-scan/src/planning/tests/scripted.rs b/vortex-scan/src/planning/tests/scripted.rs index 4035bb8ac61..5573dafa7df 100644 --- a/vortex-scan/src/planning/tests/scripted.rs +++ b/vortex-scan/src/planning/tests/scripted.rs @@ -8,6 +8,7 @@ use std::ops::Range; use std::sync::Arc; +use std::sync::LazyLock; use std::task::Context; use std::task::Poll; @@ -16,7 +17,6 @@ use vortex_array::ArrayRef; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::PrimitiveArray; use vortex_array::buffer::BufferHandle; use vortex_buffer::ByteBuffer; @@ -32,6 +32,7 @@ use vortex_io::request::IoRequestId; use vortex_io::request::IoResult; use vortex_io::request::IoSource; use vortex_io::request::IoTarget; +use vortex_session::VortexSession; use vortex_utils::aliases::hash_map::HashMap; use crate::planning::morsel::Morsel; @@ -41,6 +42,8 @@ use crate::planning::planner::PlannerOutput; use crate::planning::planner::State; use crate::planning::planner::WorkScope; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Shared record of the calls the driver made, as readable one-line events. #[derive(Clone, Default)] pub struct Log(Arc>>); @@ -407,7 +410,7 @@ pub fn array_of(n: u64) -> ArrayRef { /// An execution context over a bare array session, for `assert_arrays_eq!`. pub fn ctx() -> ExecutionCtx { - array_session().create_execution_ctx() + SESSION.create_execution_ctx() } pub fn scope(rows: Range) -> WorkScope { diff --git a/vortex-spatial/README.md b/vortex-spatial/README.md index 7f11132b822..c3af7eec152 100644 --- a/vortex-spatial/README.md +++ b/vortex-spatial/README.md @@ -27,7 +27,8 @@ Coordinates are stored as separate, non-nullable `f64` fields named `x`, `y`, an Call `initialize` before using spatial data with a session: ```rust -let session = vortex_array::array_session(); +use vortex_session::VortexSession; +let session = VortexSession::empty(); vortex_spatial::initialize(&session); ``` diff --git a/vortex-spatial/benches/area.rs b/vortex-spatial/benches/area.rs index 904dd7d8fd2..0b1b336dea7 100644 --- a/vortex-spatial/benches/area.rs +++ b/vortex-spatial/benches/area.rs @@ -40,6 +40,7 @@ static SESSION: LazyLock = LazyLock::new(spatial_session); const ROWS: usize = 128; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-spatial/benches/binary_predicates.rs b/vortex-spatial/benches/binary_predicates.rs index 90c6479efb2..f201572f037 100644 --- a/vortex-spatial/benches/binary_predicates.rs +++ b/vortex-spatial/benches/binary_predicates.rs @@ -49,6 +49,7 @@ use vortex_spatial::test_harness::spatial_session; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-spatial/benches/collect.rs b/vortex-spatial/benches/collect.rs index 7683c14b618..346320ad195 100644 --- a/vortex-spatial/benches/collect.rs +++ b/vortex-spatial/benches/collect.rs @@ -43,6 +43,7 @@ static SESSION: LazyLock = LazyLock::new(spatial_session); const ROWS: usize = 512; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-spatial/benches/convex_hull.rs b/vortex-spatial/benches/convex_hull.rs index 8145cd8af33..9192a3bc912 100644 --- a/vortex-spatial/benches/convex_hull.rs +++ b/vortex-spatial/benches/convex_hull.rs @@ -44,6 +44,7 @@ const ROWS: usize = 64; const LARGE_HULL_ROWS: usize = 16; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-spatial/benches/distance.rs b/vortex-spatial/benches/distance.rs index c3edfd8502f..db60eecf0a3 100644 --- a/vortex-spatial/benches/distance.rs +++ b/vortex-spatial/benches/distance.rs @@ -41,6 +41,7 @@ const POINT_ROWS: usize = 512; const POLYGON_ROWS: usize = 32; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-spatial/benches/envelope.rs b/vortex-spatial/benches/envelope.rs index c9aca9d7c04..bcf19454aaa 100644 --- a/vortex-spatial/benches/envelope.rs +++ b/vortex-spatial/benches/envelope.rs @@ -42,6 +42,7 @@ use vortex_spatial::test_harness::spatial_session; static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-spatial/benches/length.rs b/vortex-spatial/benches/length.rs index 24a0108e851..525d11f1bba 100644 --- a/vortex-spatial/benches/length.rs +++ b/vortex-spatial/benches/length.rs @@ -39,6 +39,7 @@ static SESSION: LazyLock = LazyLock::new(spatial_session); const ROWS: usize = 512; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-spatial/benches/make_line.rs b/vortex-spatial/benches/make_line.rs index 04cb2c47505..606f30f020c 100644 --- a/vortex-spatial/benches/make_line.rs +++ b/vortex-spatial/benches/make_line.rs @@ -40,6 +40,7 @@ static SESSION: LazyLock = LazyLock::new(spatial_session); const ROWS: usize = 512; fn main() { + LazyLock::force(&SESSION); divan::main(); } diff --git a/vortex-spatial/src/aggregate_fn/aabb.rs b/vortex-spatial/src/aggregate_fn/aabb.rs index 124ff584437..3ef24a619a7 100644 --- a/vortex-spatial/src/aggregate_fn/aabb.rs +++ b/vortex-spatial/src/aggregate_fn/aabb.rs @@ -258,6 +258,8 @@ impl AggregateFnVTable for GeometryAabb { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use geo::Rect as SpatialRect; use vortex_array::ArrayRef; use vortex_array::VortexSessionExecute; @@ -272,6 +274,7 @@ mod tests { use vortex_array::dtype::PType; use vortex_array::scalar::Scalar; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::AabbPartial; use super::GeometryAabb; @@ -285,6 +288,8 @@ mod tests { use crate::test_harness::polygon_column; use crate::test_harness::spatial_session; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// One column of every native geometry type over the same `(x, y)` vertex set. fn every_native_column(vertices: &[(f64, f64)]) -> VortexResult> { let (xs, ys): (Vec, Vec) = vertices.iter().copied().unzip(); @@ -302,7 +307,7 @@ mod tests { /// The aggregate must be serializable so the zoned writer can persist its zone-stat descriptor. #[test] fn serializes_for_zone_storage() -> VortexResult<()> { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); let metadata = GeometryAabb .serialize(&EmptyOptions)? .expect("GeometryAabb must be serializable to be stored as a zone statistic"); @@ -319,8 +324,7 @@ mod tests { /// The AABB of a Point column is the min/max of its coordinates, accumulated across batches. #[test] fn point_aabb_across_batches() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = point_column(vec![0.0], vec![0.0])?.dtype().clone(); let mut acc = Accumulator::try_new(GeometryAabb, EmptyOptions, dtype)?; @@ -336,8 +340,7 @@ mod tests { /// the origin (matching min/max, which skip nulls). #[test] fn null_rows_do_not_widen_aabb() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // The valid points sit far from the origin; the null row's storage placeholder is (0, 0). let column = nullable_point_column(vec![Some((5.0, 6.0)), None, Some((7.0, 8.0))])?; @@ -353,8 +356,7 @@ mod tests { /// unwrap, not just the bare Point struct. #[test] fn polygon_aabb_union_all_vertices() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Two rectangles: (0,0)-(2,3) and (5,5)-(7,8). The chunk AABB is their union: (0,0)-(7,8). let polygons = polygon_column(vec![ @@ -373,8 +375,7 @@ mod tests { /// covers the whole type family. #[test] fn aabb_covers_every_native_geometry_type() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); for column in every_native_column(&[(1.0, 2.0), (-1.0, 5.0), (3.0, 4.0)])? { let mut acc = Accumulator::try_new(GeometryAabb, EmptyOptions, column.dtype().clone())?; @@ -393,8 +394,7 @@ mod tests { /// the triple-`List` unwrap. #[test] fn multipolygon_aabb_union_all_vertices() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // Multipolygon 0: squares (0,0)-(1,1) and (4,4)-(5,5); multipolygon 1: square (-3,7)-(-2,9). let multipolygons = multipolygon_column(vec![ @@ -460,8 +460,7 @@ mod tests { /// never satisfy `distance <= r` anyway. #[test] fn all_nan_coordinates_kept() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let column = point_column(vec![f64::NAN, f64::NAN], vec![f64::NAN, f64::NAN])?; let mut acc = Accumulator::try_new(GeometryAabb, EmptyOptions, column.dtype().clone())?; diff --git a/vortex-spatial/src/extension/mod.rs b/vortex-spatial/src/extension/mod.rs index 4da9cd74571..047109bcec8 100644 --- a/vortex-spatial/src/extension/mod.rs +++ b/vortex-spatial/src/extension/mod.rs @@ -335,11 +335,14 @@ pub(crate) fn spatial_metadata_from_arrow(metadata: &Metadata) -> SpatialMetadat #[cfg(test)] mod tests { + use std::sync::LazyLock; + use prost::Message; use vortex_array::VortexSessionExecute; use vortex_array::dtype::DType; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use super::LineString; use super::MultiLineString; @@ -348,11 +351,13 @@ mod tests { use super::Polygon; use crate::extension::SpatialMetadata; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// Test shim: decode with an explicitly constructed session. fn native_geometry_scalar_from_wkb( bytes: &[u8], ) -> VortexResult> { - super::native_geometry_scalar_from_wkb(bytes, &vortex_array::array_session()) + super::native_geometry_scalar_from_wkb(bytes, &VortexSession::empty()) } #[test] @@ -382,7 +387,7 @@ mod tests { }; assert!(ext.is::()); assert_eq!(ext.metadata::(), &SpatialMetadata::default()); - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = crate::test_harness::point_column(vec![1.0], vec![2.0])?.execute_scalar(0, &mut ctx)?; let actual_storage = scalar.as_extension().to_storage_scalar(); @@ -412,7 +417,7 @@ mod tests { }; assert!(ext.is::()); assert_eq!(ext.metadata::(), &SpatialMetadata::default()); - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = crate::test_harness::polygon_column(vec![vec![vec![ (0.0, 0.0), (1.0, 0.0), @@ -446,7 +451,7 @@ mod tests { }; assert!(ext.is::()); assert_eq!(ext.metadata::(), &SpatialMetadata::default()); - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = crate::test_harness::linestring_column(vec![vec![(0.0, 0.0), (1.0, 1.0)]])? .execute_scalar(0, &mut ctx)?; let actual_storage = scalar.as_extension().to_storage_scalar(); @@ -478,7 +483,7 @@ mod tests { }; assert!(ext.is::()); assert_eq!(ext.metadata::(), &SpatialMetadata::default()); - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = crate::test_harness::multipoint_column(vec![vec![(0.0, 0.0), (1.0, 1.0)]])? .execute_scalar(0, &mut ctx)?; let actual_storage = scalar.as_extension().to_storage_scalar(); @@ -517,7 +522,7 @@ mod tests { ext.metadata::(), &SpatialMetadata::default() ); - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected = crate::test_harness::multilinestring_column(vec![vec![ vec![(0.0, 0.0), (1.0, 1.0)], vec![(2.0, 2.0), (3.0, 3.0)], diff --git a/vortex-spatial/src/extension/point.rs b/vortex-spatial/src/extension/point.rs index 3f3ab8c02ff..9de00619d8a 100644 --- a/vortex-spatial/src/extension/point.rs +++ b/vortex-spatial/src/extension/point.rs @@ -297,6 +297,8 @@ impl ArrowImportVTable for Point { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; @@ -307,6 +309,7 @@ mod tests { use vortex_array::dtype::PType; use vortex_array::dtype::extension::ExtDType; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::Point; use crate::extension::SpatialMetadata; @@ -316,6 +319,8 @@ mod tests { use crate::test_harness::coordinate_from_scalar; use crate::test_harness::point_column; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn spatial_meta() -> SpatialMetadata { SpatialMetadata { crs: Some("EPSG:4326".to_string()), @@ -353,8 +358,7 @@ mod tests { /// A `Point` column round-trips through scalar execution back to the original coordinates. #[test] fn point_unpacks_coordinates() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let points = point_column(vec![1.0, -111.7610], vec![2.0, 34.8697])?; diff --git a/vortex-spatial/src/extension/rect.rs b/vortex-spatial/src/extension/rect.rs index 7fac0cfe49e..162071e29a6 100644 --- a/vortex-spatial/src/extension/rect.rs +++ b/vortex-spatial/src/extension/rect.rs @@ -341,6 +341,8 @@ impl ArrowImportVTable for Rect { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use geo_types::Geometry; use rstest::rstest; use vortex_array::VortexSessionExecute; @@ -351,6 +353,7 @@ mod tests { use vortex_array::dtype::PType; use vortex_array::dtype::extension::ExtDType; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::Rect; use super::box_dimension; @@ -359,6 +362,8 @@ mod tests { use crate::extension::SpatialMetadata; use crate::extension::coordinate::Dimension; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn spatial_meta() -> SpatialMetadata { SpatialMetadata { crs: Some("EPSG:4326".to_string()), @@ -405,8 +410,7 @@ mod tests { /// A `Rect` column decodes to 2D `geo_types` rectangles. #[test] fn box_decodes_to_geo_types_rect() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let rects = crate::test_harness::rect_column(vec![(0.0, 0.0, 2.0, 3.0)])?; let storage = rects diff --git a/vortex-spatial/src/scalar_fn/area.rs b/vortex-spatial/src/scalar_fn/area.rs index a977ced15c7..cd41f2d626a 100644 --- a/vortex-spatial/src/scalar_fn/area.rs +++ b/vortex-spatial/src/scalar_fn/area.rs @@ -66,6 +66,8 @@ impl RowFn for SpatialArea { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayRef; use vortex_array::IntoArray; @@ -79,6 +81,7 @@ mod tests { use vortex_array::scalar_fn::ScalarFnVTable; use vortex_array::validity::Validity; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::SpatialArea; use crate::test_harness::linestring_column; @@ -90,6 +93,8 @@ mod tests { use crate::test_harness::polygon_column; use crate::test_harness::rect_column; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[rstest] #[case::point(point_column(vec![1.0], vec![2.0]), &[0.0])] #[case::line_string( @@ -141,8 +146,7 @@ mod tests { #[case] geometry: VortexResult, #[case] expected: &[f64], ) -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let areas = SpatialArea::try_new(geometry?)?.into_array(); let expected = PrimitiveArray::from_iter(expected.iter().copied()).into_array(); assert_arrays_eq!(areas, expected, &mut ctx); @@ -151,8 +155,7 @@ mod tests { #[test] fn propagates_nulls() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let multipolygons = nullable_multipolygon_column(vec![ Some(vec![vec![vec![ (0.0, 0.0), diff --git a/vortex-spatial/src/scalar_fn/collect.rs b/vortex-spatial/src/scalar_fn/collect.rs index 6fa2a391a06..ce52bd8fda8 100644 --- a/vortex-spatial/src/scalar_fn/collect.rs +++ b/vortex-spatial/src/scalar_fn/collect.rs @@ -315,12 +315,13 @@ impl ScalarFnVTable for SpatialCollect { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayRef; use vortex_array::Columnar; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::ExtensionArray; use vortex_array::arrays::ListArray; @@ -338,6 +339,7 @@ mod tests { use vortex_array::validity::Validity; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use super::SpatialCollect; use crate::test_harness::linestring_column; @@ -348,12 +350,14 @@ mod tests { use crate::test_harness::point_column; use crate::test_harness::polygon_column; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn list_with_validity( elements: ArrayRef, offsets: &[u32], validity: Validity, ) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); Ok(ListArray::try_new( elements, PrimitiveArray::from_iter(offsets.iter().copied()).into_array(), @@ -369,7 +373,7 @@ mod tests { /// Assert that `ST_Collect` of `input` equals `expected`. fn assert_collects(input: ArrayRef, expected: ArrayRef) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let result = SpatialCollect::try_new(input)?.into_array(); assert_arrays_eq!(result, expected, &mut ctx); @@ -389,7 +393,7 @@ mod tests { /// alone, which only holds after `MakeExact` reorders the elements. #[test] fn collects_out_of_order_list_views() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let points = nullable_point_column(vec![ Some((0.0, 4.0)), None, @@ -415,7 +419,7 @@ mod tests { #[test] fn all_valid_collect_reuses_geometry_storage() -> VortexResult<()> { let points = point_column(vec![0.0, 1.0, 2.0], vec![3.0, 4.0, 5.0])?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let point_storage = points .clone() .execute::(&mut ctx)? @@ -446,7 +450,7 @@ mod tests { } else { point_column(vec![0.0, 1.0, 2.0], vec![3.0, 4.0, 5.0])? }; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = list(points, &[0, 2, 3])?; assert!( input @@ -505,7 +509,7 @@ mod tests { nullable_point_column(vec![Some((0.0, 2.0)), None, Some((1.0, 3.0))])?, &[0, 3], )?; - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scalar = input.execute_scalar(0, &mut ctx)?; let input = ConstantArray::new(scalar, 3).into_array(); @@ -544,7 +548,7 @@ mod tests { #[test] fn propagates_null_list_rows() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = list_with_validity( point_column(vec![0.0, 1.0], vec![2.0, 3.0])?, &[0, 1, 2], diff --git a/vortex-spatial/src/scalar_fn/contains.rs b/vortex-spatial/src/scalar_fn/contains.rs index 9093f7055c2..34864cfaa5a 100644 --- a/vortex-spatial/src/scalar_fn/contains.rs +++ b/vortex-spatial/src/scalar_fn/contains.rs @@ -73,6 +73,8 @@ impl RowFn for SpatialContains { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use geo_types::Geometry; use geo_types::LineString; use geo_types::Point; @@ -96,6 +98,7 @@ mod tests { use vortex_buffer::BitBuffer; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use wkb::writer::WriteOptions; use super::SpatialContains; @@ -103,6 +106,8 @@ mod tests { use crate::test_harness::nullable_point_column; use crate::test_harness::point_column; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// A rectangle polygon with corners `(x0, y0)` and `(x1, y1)`, no holes. fn rect_polygon(x0: f64, y0: f64, x1: f64, y1: f64) -> Polygon { Polygon::new( @@ -116,7 +121,7 @@ mod tests { let mut buf = Vec::new(); wkb::writer::write_geometry(&mut buf, geometry, &WriteOptions::default()) .map_err(|e| vortex_err!("writing WKB failed: {e}"))?; - let session = vortex_array::array_session(); + let session = VortexSession::empty(); let scalar = crate::extension::native_geometry_scalar_from_wkb(&buf, &session)? .ok_or_else(|| vortex_err!("unsupported geometry type"))?; Ok(ConstantArray::new(scalar, len).into_array()) @@ -134,8 +139,7 @@ mod tests { b: ArrayRef, expected: impl IntoIterator, ) -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let contains = SpatialContains::try_new(a, b)?.into_array(); assert_arrays_eq!(contains, BoolArray::from_iter(expected), &mut ctx); Ok(()) @@ -187,8 +191,7 @@ mod tests { /// Polygon column vs constant point: only the polygon around the point contains it. #[test] fn polygon_column_vs_constant_point() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let around = materialize( geometry_constant(&Geometry::Polygon(rect_polygon(0.0, 0.0, 4.0, 4.0)), 2)?, @@ -222,8 +225,7 @@ mod tests { /// same position. #[test] fn polygon_column_vs_point_column() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let polygons = materialize( geometry_constant(&Geometry::Polygon(rect_polygon(0.0, 0.0, 4.0, 4.0)), 2)?, @@ -251,8 +253,7 @@ mod tests { /// (a strictly interior point is contained, an outside point is not). #[test] fn contains_propagates_null_rows() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let container = geometry_constant(&Geometry::Polygon(rect_polygon(0.0, 0.0, 4.0, 4.0)), 3)?; let points = nullable_point_column(vec![Some((2.0, 2.0)), None, Some((10.0, 10.0))])?; @@ -270,8 +271,7 @@ mod tests { /// A constant-null operand produces an all-null output. #[test] fn contains_constant_null_is_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let point_dtype = point_column(vec![0.0], vec![0.0])?.dtype().as_nullable(); let null_const = ConstantArray::new(Scalar::null(point_dtype), 2).into_array(); @@ -288,8 +288,7 @@ mod tests { /// container or the contained row is null, and computed on the rows valid in both. #[test] fn contains_propagates_column_pair_nulls() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); // A point contains another point only when they are equal. let container = nullable_point_column(vec![ @@ -318,8 +317,7 @@ mod tests { /// An entirely-null geometry column yields an all-null output. #[test] fn contains_all_null_column_is_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let container = geometry_constant(&Geometry::Polygon(rect_polygon(0.0, 0.0, 4.0, 4.0)), 2)?; let points = nullable_point_column(vec![None, None])?; @@ -335,8 +333,7 @@ mod tests { /// is all null. #[test] fn contains_column_pair_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let container = nullable_point_column(vec![Some((1.0, 1.0)), None])?; let contained = nullable_point_column(vec![None, Some((2.0, 2.0))])?; diff --git a/vortex-spatial/src/scalar_fn/convex_hull.rs b/vortex-spatial/src/scalar_fn/convex_hull.rs index e0a68c0e20e..244dae0f5d2 100644 --- a/vortex-spatial/src/scalar_fn/convex_hull.rs +++ b/vortex-spatial/src/scalar_fn/convex_hull.rs @@ -105,6 +105,8 @@ impl RowFn for SpatialConvexHull { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use rstest::rstest; use vortex_array::ArrayRef; use vortex_array::Columnar; @@ -120,6 +122,7 @@ mod tests { use vortex_array::validity::Validity; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use super::SpatialConvexHull; use crate::scalar_fn::area::SpatialArea; @@ -128,6 +131,8 @@ mod tests { use crate::test_harness::point_column; use crate::test_harness::polygon_column; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn computes_polygon_hulls() -> VortexResult<()> { let input = multipoint_column(vec![vec![ @@ -145,7 +150,7 @@ mod tests { (2.0, 0.0), ]]])?; let result = SpatialConvexHull::try_new(input)?.into_array(); - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -168,7 +173,7 @@ mod tests { let input = multipoint_column(vec![points])?; let expected = polygon_column(vec![expected_rings])?; let result = SpatialConvexHull::try_new(input)?.into_array(); - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); assert_arrays_eq!(result, expected, &mut ctx); Ok(()) @@ -176,7 +181,7 @@ mod tests { #[test] fn propagates_nulls() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = MaskedArray::try_new( multipoint_column(vec![ vec![(0.0, 0.0), (1.0, 0.0), (0.0, 1.0)], @@ -203,7 +208,7 @@ mod tests { #[test] fn constant_remains_constant() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let scalar = multipoint_column(vec![vec![(0.0, 0.0), (1.0, 0.0), (0.0, 1.0)]])? .execute_scalar(0, &mut ctx)?; let input = ConstantArray::new(scalar, 3).into_array(); @@ -223,7 +228,7 @@ mod tests { #[test] fn collect_hull_area_pipeline() -> VortexResult<()> { - let mut ctx = vortex_array::array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let points = point_column( vec![0.0, 2.0, 2.0, 0.0, 1.0, 0.0, 1.0, 2.0], vec![0.0, 0.0, 2.0, 2.0, 1.0, 0.0, 1.0, 2.0], diff --git a/vortex-spatial/src/scalar_fn/distance.rs b/vortex-spatial/src/scalar_fn/distance.rs index 1f4f09a4583..6575a0a1ed0 100644 --- a/vortex-spatial/src/scalar_fn/distance.rs +++ b/vortex-spatial/src/scalar_fn/distance.rs @@ -71,6 +71,8 @@ impl RowFn for SpatialDistance { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::ExecutionCtx; @@ -87,6 +89,7 @@ mod tests { use vortex_array::scalar_fn::ScalarFnVTable; use vortex_array::validity::Validity; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::SpatialDistance; use crate::test_harness::nullable_multipolygon_column; @@ -94,6 +97,8 @@ mod tests { use crate::test_harness::point_column; use crate::test_harness::polygon_column; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// A constant `Point` column of length `len`, every row at `(x, y)`. fn point_constant( x: f64, @@ -109,8 +114,7 @@ mod tests { /// (3–4–5 triangles), computed via the external `geo` crate. #[test] fn distance_over_points() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = point_column(vec![0.0, 3.0, 0.0, 3.0], vec![0.0, 0.0, 4.0, 4.0])?; let b = point_constant(0.0, 0.0, 4, &mut ctx)?; @@ -127,8 +131,7 @@ mod tests { /// Column-to-column distance pairs corresponding rows of the two columns. #[test] fn distance_between_columns() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = point_column(vec![0.0, 1.0], vec![0.0, 1.0])?; let b = point_column(vec![3.0, 1.0], vec![4.0, 1.0])?; @@ -142,8 +145,7 @@ mod tests { /// bounding rect still gets its true distance, alongside an inside point at distance zero. #[test] fn distance_to_constant_polygon_is_exact() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let ring = vec![(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0), (0.0, 0.0)]; let single = polygon_column(vec![vec![ring]])?.execute_scalar(0, &mut ctx)?; @@ -158,8 +160,7 @@ mod tests { /// The constant query point may be either operand; distance is symmetric. #[test] fn distance_with_constant_first_operand() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = point_constant(0.0, 0.0, 4, &mut ctx)?; let b = point_column(vec![0.0, 3.0, 0.0, 3.0], vec![0.0, 0.0, 4.0, 4.0])?; @@ -176,8 +177,7 @@ mod tests { /// Two constant operands: every row has the same distance. #[test] fn distance_between_two_constants() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = point_constant(0.0, 0.0, 3, &mut ctx)?; let b = point_constant(3.0, 4.0, 3, &mut ctx)?; @@ -214,8 +214,7 @@ mod tests { /// A null row in a geometry operand yields a null result; valid rows are unaffected. #[test] fn distance_propagates_null_rows() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = nullable_point_column(vec![Some((0.0, 0.0)), None, Some((3.0, 4.0))])?; let b = point_constant(0.0, 0.0, 3, &mut ctx)?; @@ -234,8 +233,7 @@ mod tests { /// valid rows get exact distances, with the null row's storage never decoded. #[test] fn distance_propagates_nulls_for_multipolygon() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let near = vec![vec![vec![ (0.0, 0.0), @@ -267,8 +265,7 @@ mod tests { /// Both operands nullable: a row is null if either operand is null there. #[test] fn distance_propagates_column_pair_nulls() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = nullable_point_column(vec![Some((0.0, 0.0)), None, Some((0.0, 0.0))])?; let b = nullable_point_column(vec![Some((3.0, 4.0)), Some((1.0, 1.0)), None])?; @@ -286,8 +283,7 @@ mod tests { /// A constant-null operand produces an all-null output. #[test] fn distance_constant_null_is_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let point_dtype = point_column(vec![0.0], vec![0.0])?.dtype().as_nullable(); let null_const = ConstantArray::new(Scalar::null(point_dtype), 3).into_array(); @@ -302,8 +298,7 @@ mod tests { /// An entirely-null geometry column yields an all-null output. #[test] fn distance_all_null_column_is_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = nullable_point_column(vec![None, None])?; let b = point_constant(0.0, 0.0, 2, &mut ctx)?; @@ -318,8 +313,7 @@ mod tests { /// is all null. #[test] fn distance_column_pair_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = nullable_point_column(vec![Some((0.0, 0.0)), None])?; let b = nullable_point_column(vec![None, Some((1.0, 1.0))])?; @@ -335,8 +329,7 @@ mod tests { /// to nullable (which would trip the result-dtype assertion against `return_dtype`). #[test] fn distance_empty_non_nullable_keeps_dtype() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = point_column(vec![], vec![])?; let b = point_column(vec![], vec![])?; diff --git a/vortex-spatial/src/scalar_fn/intersects.rs b/vortex-spatial/src/scalar_fn/intersects.rs index 3a6593b2ba2..81cc1ca0522 100644 --- a/vortex-spatial/src/scalar_fn/intersects.rs +++ b/vortex-spatial/src/scalar_fn/intersects.rs @@ -71,6 +71,8 @@ impl RowFn for SpatialIntersects { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use geo_types::Coord; use geo_types::Geometry; use geo_types::LineString; @@ -95,12 +97,15 @@ mod tests { use vortex_buffer::BitBuffer; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use wkb::writer::WriteOptions; use super::SpatialIntersects; use crate::test_harness::nullable_point_column; use crate::test_harness::point_column; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + /// A rectangle polygon with corners `(x0, y0)` and `(x1, y1)`, no holes. fn rect_polygon(x0: f64, y0: f64, x1: f64, y1: f64) -> Polygon { Polygon::new( @@ -137,7 +142,7 @@ mod tests { let mut buf = Vec::new(); wkb::writer::write_geometry(&mut buf, geometry, &WriteOptions::default()) .map_err(|e| vortex_err!("writing WKB failed: {e}"))?; - let session = vortex_array::array_session(); + let session = VortexSession::empty(); let scalar = crate::extension::native_geometry_scalar_from_wkb(&buf, &session)? .ok_or_else(|| vortex_err!("unsupported geometry type"))?; Ok(ConstantArray::new(scalar, len).into_array()) @@ -154,8 +159,7 @@ mod tests { b: ArrayRef, expected: impl IntoIterator, ) -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let intersects = SpatialIntersects::try_new(a, b)?.into_array(); assert_arrays_eq!(intersects, BoolArray::from_iter(expected), &mut ctx); Ok(()) @@ -215,8 +219,7 @@ mod tests { #[case] other: Polygon, #[case] expected: bool, ) -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let column = materialize(geometry_constant(&Geometry::Polygon(other), 2)?, &mut ctx)?; let query = geometry_constant(&Geometry::Polygon(rect_polygon(0.0, 0.0, 4.0, 4.0)), 2)?; assert_intersects(column, query, [expected; 2]) @@ -234,8 +237,7 @@ mod tests { /// same data. #[test] fn columns_agree_with_constant() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let constant = geometry_constant(&donut(), 4)?; let column = materialize(constant.clone(), &mut ctx)?; @@ -275,8 +277,7 @@ mod tests { /// (interior intersects, exterior does not). #[test] fn intersects_propagates_null_rows() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let points = nullable_point_column(vec![Some((2.0, 2.0)), None, Some((20.0, 20.0))])?; let query = geometry_constant(&donut(), 3)?; @@ -294,8 +295,7 @@ mod tests { /// A constant-null operand produces an all-null output. #[test] fn intersects_constant_null_is_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let point_dtype = point_column(vec![0.0], vec![0.0])?.dtype().as_nullable(); let null_const = ConstantArray::new(Scalar::null(point_dtype), 2).into_array(); @@ -312,8 +312,7 @@ mod tests { /// computed on the rows valid in both (points intersect exactly when equal). #[test] fn intersects_propagates_column_pair_nulls() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = nullable_point_column(vec![ Some((0.0, 0.0)), @@ -341,8 +340,7 @@ mod tests { /// An entirely-null geometry column yields an all-null output. #[test] fn intersects_all_null_column_is_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let points = nullable_point_column(vec![None, None])?; let query = geometry_constant(&donut(), 2)?; @@ -358,8 +356,7 @@ mod tests { /// is all null. #[test] fn intersects_column_pair_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let a = nullable_point_column(vec![Some((0.0, 0.0)), None])?; let b = nullable_point_column(vec![None, Some((1.0, 1.0))])?; diff --git a/vortex-spatial/src/scalar_fn/length.rs b/vortex-spatial/src/scalar_fn/length.rs index a539f9f0c63..9512008e2c4 100644 --- a/vortex-spatial/src/scalar_fn/length.rs +++ b/vortex-spatial/src/scalar_fn/length.rs @@ -215,6 +215,8 @@ impl ScalarFnVTable for SpatialLength { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::ArrayRef; use vortex_array::Columnar; use vortex_array::ExecutionCtx; @@ -233,12 +235,15 @@ mod tests { use vortex_array::validity::Validity; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use super::SpatialLength; use crate::test_harness::linestring_column; use crate::test_harness::multilinestring_column; use crate::test_harness::point_column; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn line_constant( line: Vec<(f64, f64)>, len: usize, @@ -250,8 +255,7 @@ mod tests { #[test] fn measures_each_linestring() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lines = linestring_column(vec![ vec![(0.0, 0.0), (3.0, 4.0)], vec![(0.0, 0.0), (3.0, 4.0), (3.0, 8.0)], @@ -268,8 +272,7 @@ mod tests { #[test] fn measures_each_multilinestring() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lines = multilinestring_column(vec![ vec![ vec![(0.0, 0.0), (3.0, 4.0)], @@ -288,8 +291,7 @@ mod tests { #[test] fn propagates_nullable_multilinestring_rows() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lines = MaskedArray::try_new( multilinestring_column(vec![ vec![vec![(0.0, 0.0), (3.0, 4.0)]], @@ -314,8 +316,7 @@ mod tests { #[test] fn constant_is_computed_once_and_remains_constant() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lines = line_constant(vec![(0.0, 0.0), (3.0, 4.0), (3.0, 8.0)], 3, &mut ctx)?; let result = SpatialLength::try_new(lines)? @@ -331,8 +332,7 @@ mod tests { #[test] fn null_constant_is_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let dtype = linestring_column(vec![vec![]])?.dtype().as_nullable(); let lines = ConstantArray::new(Scalar::null(dtype), 2).into_array(); @@ -351,8 +351,7 @@ mod tests { #[test] fn propagates_nullable_rows() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lines = MaskedArray::try_new( linestring_column(vec![ vec![(0.0, 0.0), (3.0, 4.0)], @@ -376,8 +375,7 @@ mod tests { #[test] fn propagates_all_null_rows() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let lines = MaskedArray::try_new( linestring_column(vec![ vec![(0.0, 0.0), (3.0, 4.0)], diff --git a/vortex-spatial/src/scalar_fn/make_line.rs b/vortex-spatial/src/scalar_fn/make_line.rs index 22b0bdf5947..406b05e6dc1 100644 --- a/vortex-spatial/src/scalar_fn/make_line.rs +++ b/vortex-spatial/src/scalar_fn/make_line.rs @@ -233,6 +233,8 @@ impl ScalarFnVTable for SpatialMakeLine { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use geo_types::Coord; use geo_types::Geometry; use geo_types::LineString as GeoLineString; @@ -253,6 +255,7 @@ mod tests { use vortex_array::scalar_fn::ScalarFnVTable; use vortex_error::VortexResult; use vortex_error::vortex_err; + use vortex_session::VortexSession; use super::SpatialMakeLine; use crate::extension::LineString; @@ -265,6 +268,8 @@ mod tests { use crate::extension::geometries; use crate::test_harness::point_column; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn dimensional_point( dimension: Dimension, coordinate: [f64; 4], @@ -302,8 +307,7 @@ mod tests { #[test] fn connects_paired_points_in_operand_order() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let starts = point_column(vec![0.0, 3.0], vec![0.0, 4.0])?; let ends = point_column(vec![3.0, 0.0], vec![4.0, 0.0])?; @@ -327,8 +331,7 @@ mod tests { #[test] fn two_constants_are_built_once_and_remain_constant() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let starts = point_constant(0.0, 0.0, 3, &mut ctx)?; let ends = point_constant(3.0, 4.0, 3, &mut ctx)?; @@ -358,8 +361,7 @@ mod tests { #[case::constant_start(true)] #[case::constant_end(false)] fn constant_and_column_are_paired_by_row(#[case] constant_start: bool) -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let constant = point_constant(0.0, 0.0, 2, &mut ctx)?; let column = point_column(vec![3.0, 6.0], vec![4.0, 8.0])?; let (starts, ends) = if constant_start { @@ -388,8 +390,7 @@ mod tests { #[test] fn null_constant_is_all_null() -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let point_dtype = point_column(vec![0.0], vec![0.0])?.dtype().as_nullable(); let starts = ConstantArray::new(Scalar::null(point_dtype), 2).into_array(); let ends = point_column(vec![3.0, 6.0], vec![4.0, 8.0])?; @@ -454,8 +455,7 @@ mod tests { #[case] expected_z: Option<[f64; 2]>, #[case] expected_m: Option<[f64; 2]>, ) -> VortexResult<()> { - let session = vortex_array::array_session(); - let mut ctx = session.create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let expected_x = [start[0], end[0]]; let expected_y = [start[1], end[1]]; let start = dimensional_point(start_dimension, start, None)?; diff --git a/vortex-spatial/src/test_harness.rs b/vortex-spatial/src/test_harness.rs index 5ee5f1ab8d9..d6f30d51162 100644 --- a/vortex-spatial/src/test_harness.rs +++ b/vortex-spatial/src/test_harness.rs @@ -6,7 +6,6 @@ use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::ExtensionArray; use vortex_array::arrays::ListArray; use vortex_array::arrays::PrimitiveArray; @@ -42,7 +41,7 @@ use crate::extension::polygon_storage_dtype; /// A fresh session with the spatial types, functions, and pruning rules registered. pub fn spatial_session() -> VortexSession { - let session = array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session } @@ -71,7 +70,7 @@ fn offset(n: usize) -> VortexResult { /// Wrap `elements` — built from `rows` flattened one level — in a non-nullable `List` with one /// entry per row. fn nest(rows: &[Vec], elements: ArrayRef) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let mut offsets = vec![0i32]; let mut len = 0usize; for row in rows { @@ -186,7 +185,7 @@ pub fn multipolygon_column(multipolygons: Vec) -> VortexResul pub fn nullable_multipolygon_column( multipolygons: Vec>, ) -> VortexResult { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let rows: Vec = multipolygons .iter() .map(|row| row.clone().unwrap_or_default()) diff --git a/vortex-tensor/benches/cosine_similarity.rs b/vortex-tensor/benches/cosine_similarity.rs index 5b800ff0c92..d701084d684 100644 --- a/vortex-tensor/benches/cosine_similarity.rs +++ b/vortex-tensor/benches/cosine_similarity.rs @@ -12,12 +12,15 @@ #![expect(clippy::unwrap_used)] +use std::sync::LazyLock; + use divan::Bencher; use mimalloc::MiMalloc; use vortex_array::ArrayRef; use vortex_array::EmptyMetadata; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::ConstantArray; use vortex_array::arrays::ExtensionArray; use vortex_array::arrays::FixedSizeListArray; @@ -25,18 +28,37 @@ use vortex_array::arrays::PrimitiveArray; use vortex_array::dtype::DType; use vortex_array::dtype::Nullability; use vortex_array::dtype::PType; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; use vortex_array::scalar::Scalar; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; +use vortex_session::VortexSession; use vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity; use vortex_tensor::vector::Vector; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + // Scalar function execution allocates its output inside the timed region, so use the vendored // allocator instead of measuring glibc differences between CodSpeed runner images. #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -81,14 +103,13 @@ fn constant_vector(width: usize) -> ArrayRef { } fn bench_cosine(bencher: Bencher, lhs: ArrayRef, rhs: ArrayRef) { - let session = vortex_array::array_session(); bencher .with_inputs(|| { ( CosineSimilarity::try_new(lhs.clone(), rhs.clone()) .unwrap() .into_array(), - session.create_execution_ctx(), + SESSION.create_execution_ctx(), ) }) .bench_values(|(array, mut ctx)| array.execute::(&mut ctx).unwrap()); diff --git a/vortex-tensor/benches/inner_product.rs b/vortex-tensor/benches/inner_product.rs index 9d6905d5861..3b02302cd38 100644 --- a/vortex-tensor/benches/inner_product.rs +++ b/vortex-tensor/benches/inner_product.rs @@ -11,27 +11,48 @@ #![expect(clippy::unwrap_used)] +use std::sync::LazyLock; + use divan::Bencher; use divan::counter::ItemsCount; use mimalloc::MiMalloc; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::MaskedArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; +use vortex_session::VortexSession; use vortex_tensor::scalar_fns::inner_product::InnerProduct; use vortex_tensor::vector::Vector; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + // Scalar function execution allocates its output inside the timed region, so use the vendored // allocator instead of measuring glibc differences between CodSpeed runner images. #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -58,7 +79,6 @@ fn vectors(width: usize, seed: usize) -> ArrayRef { } fn bench_inner_product(bencher: Bencher, lhs: ArrayRef, rhs: ArrayRef) { - let session = array_session(); bencher .counter(ItemsCount::new(lhs.len())) .with_inputs(|| { @@ -66,7 +86,7 @@ fn bench_inner_product(bencher: Bencher, lhs: ArrayRef, rhs: ArrayRef) { InnerProduct::try_new(lhs.clone(), rhs.clone()) .unwrap() .into_array(), - session.create_execution_ctx(), + SESSION.create_execution_ctx(), ) }) .bench_values(|(array, mut ctx)| array.execute::(&mut ctx).unwrap()); @@ -79,7 +99,7 @@ fn non_nullable(bencher: Bencher, width: usize) { #[divan::bench(args = WIDTHS)] fn nullable(bencher: Bencher, width: usize) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let validity = Validity::from_iter((0..ELEMENTS / width).map(|i| i % 8 != 0)); let lhs = MaskedArray::try_new(vectors(width, 0), validity, &mut ctx) .unwrap() diff --git a/vortex-tensor/benches/l2_norm.rs b/vortex-tensor/benches/l2_norm.rs index a7c3d9bae83..d9f362853d2 100644 --- a/vortex-tensor/benches/l2_norm.rs +++ b/vortex-tensor/benches/l2_norm.rs @@ -11,27 +11,48 @@ #![expect(clippy::unwrap_used)] +use std::sync::LazyLock; + use divan::Bencher; use divan::counter::ItemsCount; use mimalloc::MiMalloc; use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; +use vortex_array::aggregate_fn::session::AggregateFnSession; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::MaskedArray; use vortex_array::arrays::PrimitiveArray; +use vortex_array::dtype::session::DTypeSession; +use vortex_array::memory::MemorySession; +use vortex_array::optimizer::kernels::KernelSession; +use vortex_array::scalar_fn::session::ScalarFnSession; +use vortex_array::session::ArraySession; +use vortex_array::stats::session::StatsSession; use vortex_array::validity::Validity; use vortex_buffer::Buffer; +use vortex_session::VortexSession; use vortex_tensor::scalar_fns::l2_norm::L2Norm; use vortex_tensor::vector::Vector; +static SESSION: LazyLock = LazyLock::new(|| { + VortexSession::empty() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() + .with::() +}); + // Scalar function execution allocates its output inside the timed region, so use the vendored // allocator instead of measuring glibc differences between CodSpeed runner images. #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { + LazyLock::force(&SESSION); divan::main(); } @@ -56,13 +77,12 @@ fn vectors(width: usize) -> ArrayRef { } fn bench_l2_norm(bencher: Bencher, input: ArrayRef) { - let session = array_session(); bencher .counter(ItemsCount::new(input.len())) .with_inputs(|| { ( L2Norm::try_new(input.clone()).unwrap().into_array(), - session.create_execution_ctx(), + SESSION.create_execution_ctx(), ) }) .bench_values(|(array, mut ctx)| array.execute::(&mut ctx).unwrap()); @@ -75,7 +95,7 @@ fn non_nullable(bencher: Bencher, width: usize) { #[divan::bench(args = WIDTHS)] fn nullable(bencher: Bencher, width: usize) { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let validity = Validity::from_iter((0..ELEMENTS / width).map(|i| i % 8 != 0)); let input = MaskedArray::try_new(vectors(width), validity, &mut ctx) .unwrap() diff --git a/vortex-tensor/src/editions.rs b/vortex-tensor/src/editions.rs index bd34ca7102a..30ab04d8c08 100644 --- a/vortex-tensor/src/editions.rs +++ b/vortex-tensor/src/editions.rs @@ -42,16 +42,23 @@ pub static DECLARATION: EditionDeclaration = EditionDeclaration { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_edition::EditionSessionExt; use vortex_edition::test_harness::validate_edition; use vortex_error::VortexResult; + use vortex_session::VortexSession; use super::*; + static SESSION: LazyLock = LazyLock::new(|| { + let session = VortexSession::empty(); + crate::initialize(&session); + session + }); + #[test] fn tensor_edition_is_valid() -> VortexResult<()> { - let session = vortex_array::array_session(); - crate::initialize(&session); - validate_edition(&session.editions(), &TENSOR_2026_04) + validate_edition(&SESSION.editions(), &TENSOR_2026_04) } } diff --git a/vortex-tensor/src/lib.rs b/vortex-tensor/src/lib.rs index 545db0720e8..a6f9ea2a623 100644 --- a/vortex-tensor/src/lib.rs +++ b/vortex-tensor/src/lib.rs @@ -104,7 +104,7 @@ mod tests { use vortex_session::VortexSession; pub static SESSION: LazyLock = LazyLock::new(|| { - let session = vortex_array::array_session(); + let session = VortexSession::empty(); crate::initialize(&session); session }); diff --git a/vortex-tensor/src/scalar_fns/l2_normalize.rs b/vortex-tensor/src/scalar_fns/l2_normalize.rs index 0bb02b95fcb..ff3d068529d 100644 --- a/vortex-tensor/src/scalar_fns/l2_normalize.rs +++ b/vortex-tensor/src/scalar_fns/l2_normalize.rs @@ -254,7 +254,6 @@ mod tests { use vortex_array::ArrayRef; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::arrays::ExtensionArray; use vortex_array::arrays::FixedSizeListArray; use vortex_array::arrays::MaskedArray; @@ -486,7 +485,7 @@ mod tests { #[test] fn test_return_dtype_has_nonnullable_fields() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let input = vector_array(2, &[3.0f64, 4.0])?; let input = MaskedArray::try_new(input, Validity::AllValid, &mut ctx)?.into_array(); let output = L2Normalize::try_new(input)?.into_array(); diff --git a/vortex-test/compat-gen/src/check.rs b/vortex-test/compat-gen/src/check.rs index ce8b29078ef..a2834fa733b 100644 --- a/vortex-test/compat-gen/src/check.rs +++ b/vortex-test/compat-gen/src/check.rs @@ -6,12 +6,12 @@ use std::path::Path; use clap::ValueEnum; use serde::Serialize; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::assert_arrays_eq; use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_err; +use vortex_session::VortexSession; use crate::adapter; use crate::fixtures::all_fixtures; @@ -48,7 +48,7 @@ struct FailedFixture { /// Prints JSON result to stdout, human-readable progress to stderr. /// Returns error if any fixture failed or if mode constraints are violated. pub fn check(dir: &Path, mode: Mode, exclude: &[String]) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let fixtures = all_fixtures(); let fixtures: Vec<_> = fixtures .into_iter() diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/mod.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/mod.rs index eb453478017..de8c2165854 100644 --- a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/mod.rs +++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/mod.rs @@ -17,18 +17,22 @@ pub fn fixtures() -> Vec> { #[cfg(test)] mod tests { + use std::sync::LazyLock; + use vortex_array::VortexSessionExecute; - use vortex_array::array_session; use vortex_array::assert_arrays_eq; + use vortex_session::VortexSession; use super::fixtures; use crate::adapter; use crate::fixtures::check_expected_encodings; + static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + #[test] fn roundtrip_fixtures_to_bytes() { for fixture in fixtures() { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); let array = fixture.build(&mut ctx).unwrap(); check_expected_encodings(&array, fixture.as_ref()).unwrap(); let bytes = adapter::write_file_to_bytes(array.clone()).unwrap(); diff --git a/vortex-test/compat-gen/src/generate.rs b/vortex-test/compat-gen/src/generate.rs index 706c064ed70..a888a41bb5c 100644 --- a/vortex-test/compat-gen/src/generate.rs +++ b/vortex-test/compat-gen/src/generate.rs @@ -9,9 +9,9 @@ use sha2::Digest; use sha2::Sha256; use vortex_array::ExecutionCtx; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_error::VortexResult; use vortex_error::vortex_err; +use vortex_session::VortexSession; use crate::fixtures::all_fixtures; @@ -90,7 +90,7 @@ pub fn write_manifest(output_dir: &Path, infos: Vec) -> VortexResul /// Generate all fixtures into `output_dir` and write the manifest. pub fn generate(output_dir: &Path, exclude: &[String]) -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = VortexSession::empty().create_execution_ctx(); let infos = write_fixtures(output_dir, exclude, &mut ctx)?; write_manifest(output_dir, infos) } diff --git a/vortex-test/e2e-cuda/src/lib.rs b/vortex-test/e2e-cuda/src/lib.rs index 75a7e8453e7..c573a70cdda 100644 --- a/vortex-test/e2e-cuda/src/lib.rs +++ b/vortex-test/e2e-cuda/src/lib.rs @@ -35,7 +35,6 @@ use futures::executor::block_on; use vortex::array::ArrayRef as VortexArrayRef; use vortex::array::IntoArray; use vortex::array::VortexSessionExecute; -use vortex::array::array_session; use vortex::array::arrays::BoolArray; use vortex::array::arrays::DecimalArray; use vortex::array::arrays::DictArray as VortexDictArray; @@ -70,7 +69,7 @@ use vortex_cuda::arrow::DeviceArrayStreamExt; const PRIMITIVE_DTYPE_ENV: &str = "VORTEX_CUDF_PRIMITIVE_DTYPE"; static SESSION: LazyLock = LazyLock::new(|| { - array_session() + VortexSession::empty() .with::() .with::() .with::() @@ -146,7 +145,7 @@ fn list_array() -> VortexArrayRef { PrimitiveArray::from_iter([10i32, 11, 12, 13, 14]).into_array(), PrimitiveArray::from_iter([0i32, 2, 2, 5, 5, 5]).into_array(), Validity::from_iter([true, false, true, true, false]), - &mut array_session().create_execution_ctx(), + &mut VortexSession::empty().create_execution_ctx(), ) .expect("list array") .into_array() @@ -167,7 +166,7 @@ fn fixed_size_list_as_list_array() -> VortexArrayRef { PrimitiveArray::from_iter(20i32..30).into_array(), PrimitiveArray::from_iter([0i32, 2, 4, 6, 8, 10]).into_array(), Validity::from_iter([true, false, true, true, false]), - &mut array_session().create_execution_ctx(), + &mut VortexSession::empty().create_execution_ctx(), ) .expect("fixed-size-list as list array") .into_array() @@ -204,7 +203,7 @@ fn multi_buffer_varbinview(dtype: DType) -> VortexArrayRef { Arc::from([first, second]), dtype, Validity::NonNullable, - &mut array_session().create_execution_ctx(), + &mut VortexSession::empty().create_execution_ctx(), ) .expect("multi-buffer VarBinViewArray") .into_array() diff --git a/vortex/src/editions/tests.rs b/vortex/src/editions/tests.rs index b1e8c67cd4e..c116f73796f 100644 --- a/vortex/src/editions/tests.rs +++ b/vortex/src/editions/tests.rs @@ -1,11 +1,12 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::LazyLock; + use vortex_array::ArrayRef; use vortex_array::ExecutionCtx; use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; -use vortex_array::array_session; use vortex_array::arrays::ChunkedArray; use vortex_array::arrays::ExtensionArray; use vortex_array::arrays::ListArray; @@ -53,6 +54,8 @@ use super::DEFAULT_PREVIEW_EDITION; use super::EDITION_DECLARATIONS; use super::PREVIEW_2026_08_0; +static SESSION: LazyLock = LazyLock::new(VortexSession::empty); + fn session() -> VortexResult { let session = EditionSession::empty(); for family in super::EDITION_FAMILIES { @@ -380,7 +383,7 @@ static WRITER_TEST_DECLARATION: EditionDeclaration = EditionDeclaration { }; fn writer_test_session() -> VortexResult { - let session = array_session() + let session = VortexSession::empty() .with::() .with::() .with::(); @@ -392,7 +395,7 @@ fn writer_test_session() -> VortexResult { #[tokio::test] async fn disabling_editions_allows_uneditioned_components() -> VortexResult<()> { - let enforced_session = array_session() + let enforced_session = VortexSession::empty() .with::() .with::() .with::(); @@ -419,7 +422,7 @@ async fn disabling_editions_allows_uneditioned_components() -> VortexResult<()> "unexpected error: {error}" ); - let uneditioned_session = array_session() + let uneditioned_session = VortexSession::empty() .with::() .with::(); vortex_file::register_default_encodings(&uneditioned_session); @@ -486,7 +489,7 @@ fn session_declaring(members: &[(ComponentKind, Id)]) -> VortexResult() .with::() .with::(); @@ -570,7 +573,7 @@ async fn writer_restricts_layouts_to_the_enabled_editions() -> VortexResult<()> /// The writer emits the list layout exactly when the enabled editions include it. #[tokio::test] async fn list_layout_follows_enabled_editions() -> VortexResult<()> { - let mut ctx = array_session().create_execution_ctx(); + let mut ctx = SESSION.create_execution_ctx(); use crate::VortexSessionDefault; let list = ListArray::try_new(