Use a single session and ExecutionCtx per touched test

Consolidate the validity/scalar checks in the tests updated by the
`execute_is_valid` migration so each test creates one execution context
and reuses it, instead of constructing a fresh `LEGACY_SESSION` context
per call (some inside loops). Also unify the ALP sliced-vector test on a
single `SESSION` context for both encode and execute, rather than mixing
`SESSION` and `LEGACY_SESSION`.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: claude

encodings/alp/src/alp/array.rs

@@ -695,19 +695,14 @@ mod tests {
             })
             .collect();
 
+        let mut ctx = SESSION.create_execution_ctx();
         let array = PrimitiveArray::from_option_iter(values.clone());
-        let encoded = alp_encode(
-            array.as_view(),
-            None,
-            &mut LEGACY_SESSION.create_execution_ctx(),
-        )
-        .unwrap();
+        let encoded = alp_encode(array.as_view(), None, &mut ctx).unwrap();
 
         let slice_end = size - slice_start;
         let slice_len = slice_end - slice_start;
         let sliced_encoded = encoded.slice(slice_start..slice_end).unwrap();
 
-        let mut ctx = SESSION.create_execution_ctx();
         let result_canonical = sliced_encoded.execute::<Canonical>(&mut ctx).unwrap();
         let result_primitive = result_canonical.into_primitive();
 

vortex-array/src/builders/fixed_size_list.rs

@@ -443,6 +443,7 @@ mod tests {
 
     #[test]
     fn test_nullable_lists_non_nullable_elements() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, NonNullable));
         let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0);
 
@@ -474,21 +475,21 @@ mod tests {
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
     }
@@ -561,6 +562,7 @@ mod tests {
 
     #[test]
     fn test_append_nulls() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         // Elements must be nullable if we're going to append null lists
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
         let mut builder = FixedSizeListBuilder::with_capacity(dtype, 2, Nullable, 0);
@@ -582,14 +584,15 @@ mod tests {
                 !fsl_array
                     .validity()
                     .vortex_expect("fixed-size-list validity should be derivable")
-                    .execute_is_valid(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_is_valid(i, &mut ctx)
                     .unwrap()
             );
         }
     }
 
     #[test]
     fn test_append_scalar_nulls() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         // Elements must be nullable if we're going to append null lists
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
         let mut builder = FixedSizeListBuilder::with_capacity(dtype, 2, Nullable, 0);
@@ -612,7 +615,7 @@ mod tests {
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
     }
@@ -662,6 +665,7 @@ mod tests {
 
     #[test]
     fn test_extend_from_array() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Create a source array.
@@ -690,48 +694,49 @@ mod tests {
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(3, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(3, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(4, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(4, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(5, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(5, &mut ctx)
                 .unwrap()
         );
     }
 
     #[test]
     fn test_extend_degenerate_arrays() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Create degenerate source arrays (size = 0).
@@ -767,35 +772,35 @@ mod tests {
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(3, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(3, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(4, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(4, &mut ctx)
                 .unwrap()
         );
     }
@@ -836,6 +841,7 @@ mod tests {
 
     #[test]
     fn test_mixed_operations() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         // Use nullable elements since we'll be appending nulls
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
         let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0);
@@ -879,48 +885,49 @@ mod tests {
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         ); // append_value
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         ); // append_null
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         ); // append_zeros
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(3, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(3, &mut ctx)
                 .unwrap()
         ); // append_zeros
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(4, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(4, &mut ctx)
                 .unwrap()
         ); // append_nulls
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(5, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(5, &mut ctx)
                 .unwrap()
         ); // extend_from_array
     }
 
     #[test]
     fn test_append_scalar() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 10);
 
@@ -942,19 +949,15 @@ mod tests {
 
         // Check actual values using scalar_at.
 
-        let scalar0 = array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar0 = array.execute_scalar(0, &mut ctx).unwrap();
         let list0 = scalar0.as_list();
         assert_eq!(list0.len(), 2);
         if let Some(list0_items) = list0.elements() {
             assert_eq!(list0_items[0].as_primitive().typed_value::<i32>(), Some(1));
             assert_eq!(list0_items[1].as_primitive().typed_value::<i32>(), Some(2));
         }
 
-        let scalar1 = array
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar1 = array.execute_scalar(1, &mut ctx).unwrap();
         let list1 = scalar1.as_list();
         assert_eq!(list1.len(), 2);
         if let Some(list1_items) = list1.elements() {
@@ -967,21 +970,21 @@ mod tests {
             array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             !array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .execute_is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
 

vortex-array/src/builders/list.rs

@@ -579,21 +579,19 @@ mod tests {
         let array = builder.finish_into_list();
         assert_eq!(array.len(), 3);
 
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
         // Check actual values using scalar_at.
 
-        let scalar0 = array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar0 = array.execute_scalar(0, &mut ctx).unwrap();
         let list0 = scalar0.as_list();
         assert_eq!(list0.len(), 2);
         if let Some(list0_items) = list0.elements() {
             assert_eq!(list0_items[0].as_primitive().typed_value::<i32>(), Some(1));
             assert_eq!(list0_items[1].as_primitive().typed_value::<i32>(), Some(2));
         }
 
-        let scalar1 = array
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar1 = array.execute_scalar(1, &mut ctx).unwrap();
         let list1 = scalar1.as_list();
         assert_eq!(list1.len(), 3);
         if let Some(list1_items) = list1.elements() {
@@ -602,9 +600,7 @@ mod tests {
             assert_eq!(list1_items[2].as_primitive().typed_value::<i32>(), Some(5));
         }
 
-        let scalar2 = array
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar2 = array.execute_scalar(2, &mut ctx).unwrap();
         let list2 = scalar2.as_list();
         assert!(list2.is_null()); // This should be null.
 
@@ -613,21 +609,21 @@ mod tests {
             array
                 .validity()
                 .vortex_expect("list validity should be derivable")
-                .execute_is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             array
                 .validity()
                 .vortex_expect("list validity should be derivable")
-                .execute_is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             !array
                 .validity()
                 .vortex_expect("list validity should be derivable")
-                .execute_is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );