Replace ToCanonical trait usages with execute

encodings/alp/src/alp/compute/cast.rs

@@ -154,7 +154,7 @@ mod tests {
         let array_primitive = array.execute::<PrimitiveArray>(&mut ctx)?;
         let alp =
             alp_encode(array_primitive.as_view(), None, &mut ctx).vortex_expect("cannot fail");
-        test_cast_conformance(&alp.into_array());
+        test_cast_conformance(&alp.into_array(), &mut ctx);
 
         Ok(())
     }

encodings/alp/src/alp/compute/filter.rs

@@ -65,6 +65,6 @@ mod test {
         let mut ctx = array_session().create_execution_ctx();
         let array_primitive = array.execute::<PrimitiveArray>(&mut ctx).unwrap();
         let alp = alp_encode(array_primitive.as_view(), None, &mut ctx).unwrap();
-        test_filter_conformance(&alp.into_array());
+        test_filter_conformance(&alp.into_array(), &mut ctx);
     }
 }

encodings/alp/src/alp/compute/mask.rs

@@ -81,7 +81,7 @@ mod test {
         let mut ctx = array_session().create_execution_ctx();
         let array_primitive = array.execute::<PrimitiveArray>(&mut ctx).unwrap();
         let alp = alp_encode(array_primitive.as_view(), None, &mut ctx).unwrap();
-        test_mask_conformance(&alp.into_array());
+        test_mask_conformance(&alp.into_array(), &mut ctx);
     }
 
     #[test]
@@ -95,7 +95,7 @@ mod test {
         let array = PrimitiveArray::from_iter(values);
         let alp = alp_encode(array.as_view(), None, &mut ctx).unwrap();
         assert!(alp.patches().is_some(), "expected patches");
-        test_mask_conformance(&alp.into_array());
+        test_mask_conformance(&alp.into_array(), &mut ctx);
     }
 
     #[test]

encodings/alp/src/alp/compute/take.rs

@@ -59,6 +59,6 @@ mod test {
         let mut ctx = array_session().create_execution_ctx();
         let array_primitive = array.execute::<PrimitiveArray>(&mut ctx).unwrap();
         let alp = alp_encode(array_primitive.as_view(), None, &mut ctx).unwrap();
-        test_take_conformance(&alp.into_array());
+        test_take_conformance(&alp.into_array(), &mut ctx);
     }
 }

encodings/alp/src/alp_rd/compute/cast.rs

@@ -149,6 +149,9 @@ mod tests {
         encoder.encode(arr.as_view(), &mut array_session().create_execution_ctx())
     })]
     fn test_cast_alprd_conformance(#[case] alprd: crate::alp_rd::ALPRDArray) {
-        test_cast_conformance(&alprd.into_array());
+        test_cast_conformance(
+            &alprd.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }

encodings/alp/src/alp_rd/compute/filter.rs

@@ -95,6 +95,7 @@ mod test {
                     &mut ctx,
                 )
                 .into_array(),
+            &mut ctx,
         );
     }
 
@@ -111,6 +112,7 @@ mod test {
                     &mut ctx,
                 )
                 .into_array(),
+            &mut ctx,
         );
     }
 }

encodings/alp/src/alp_rd/compute/mask.rs

@@ -63,6 +63,7 @@ mod tests {
                     &mut ctx,
                 )
                 .into_array(),
+            &mut ctx,
         );
     }
 
@@ -79,6 +80,7 @@ mod tests {
                     &mut ctx,
                 )
                 .into_array(),
+            &mut ctx,
         );
     }
 }

encodings/alp/src/alp_rd/compute/take.rs

@@ -149,6 +149,7 @@ mod test {
                     &mut ctx,
                 )
                 .into_array(),
+            &mut ctx,
         );
     }
 
@@ -165,6 +166,7 @@ mod test {
                     &mut ctx,
                 )
                 .into_array(),
+            &mut ctx,
         );
     }
 }

encodings/bytebool/src/compute.rs

@@ -297,17 +297,25 @@ mod tests {
 
     #[test]
     fn test_mask_byte_bool() {
-        test_mask_conformance(&bb(vec![true, false, true, true, false]).into_array());
+        test_mask_conformance(
+            &bb(vec![true, false, true, true, false]).into_array(),
+            &mut SESSION.create_execution_ctx(),
+        );
         test_mask_conformance(
             &bb_opt(vec![Some(true), Some(true), None, Some(false), None]).into_array(),
+            &mut SESSION.create_execution_ctx(),
         );
     }
 
     #[test]
     fn test_filter_byte_bool() {
-        test_filter_conformance(&bb(vec![true, false, true, true, false]).into_array());
+        test_filter_conformance(
+            &bb(vec![true, false, true, true, false]).into_array(),
+            &mut SESSION.create_execution_ctx(),
+        );
         test_filter_conformance(
             &bb_opt(vec![Some(true), Some(true), None, Some(false), None]).into_array(),
+            &mut SESSION.create_execution_ctx(),
         );
     }
 
@@ -317,7 +325,7 @@ mod tests {
     #[case(bb(vec![true, false]))]
     #[case(bb(vec![true]))]
     fn test_take_byte_bool_conformance(#[case] array: ByteBoolArray) {
-        test_take_conformance(&array.into_array());
+        test_take_conformance(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 
     #[test]
@@ -338,7 +346,7 @@ mod tests {
     #[case(bb(vec![true]))]
     #[case(bb_opt(vec![Some(true), None]))]
     fn test_cast_bytebool_conformance(#[case] array: ByteBoolArray) {
-        test_cast_conformance(&array.into_array());
+        test_cast_conformance(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 
     #[rstest]

encodings/datetime-parts/src/compute/cast.rs

@@ -140,6 +140,9 @@ mod tests {
     ), &mut array_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());
+        test_cast_conformance(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }

encodings/datetime-parts/src/compute/filter.rs

@@ -54,7 +54,7 @@ mod test {
             TemporalArray::new_timestamp(timestamps, TimeUnit::Milliseconds, Some("UTC".into()));
 
         let array = DateTimeParts::try_from_temporal(temporal, &mut ctx).unwrap();
-        test_filter_conformance(&array.into_array());
+        test_filter_conformance(&array.into_array(), &mut ctx);
 
         // Test with nullable values
         let timestamps = PrimitiveArray::from_option_iter([
@@ -70,6 +70,6 @@ mod test {
             TemporalArray::new_timestamp(timestamps, TimeUnit::Milliseconds, Some("UTC".into()));
 
         let array = DateTimeParts::try_from_temporal(temporal, &mut ctx).unwrap();
-        test_filter_conformance(&array.into_array());
+        test_filter_conformance(&array.into_array(), &mut ctx);
     }
 }

encodings/datetime-parts/src/compute/take.rs

@@ -136,6 +136,9 @@ mod tests {
         Some("UTC".into())
     ), &mut array_session().create_execution_ctx()).unwrap())]
     fn test_take_datetime_parts_conformance(#[case] array: DateTimePartsArray) {
-        test_take_conformance(&array.into_array());
+        test_take_conformance(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }

encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs

@@ -118,6 +118,9 @@ mod tests {
         DecimalDType::new(10, 2),
     ).unwrap())]
     fn test_cast_decimal_byte_parts_conformance(#[case] array: DecimalBytePartsArray) {
-        test_cast_conformance(&array.into_array());
+        test_cast_conformance(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }

encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs

@@ -27,6 +27,8 @@ impl FilterReduce for DecimalByteParts {
 #[cfg(test)]
 mod test {
     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;
@@ -41,14 +43,20 @@ mod test {
 
         let decimal_dtype = DecimalDType::new(8, 2);
         let array = DecimalByteParts::try_new(msp, decimal_dtype).unwrap();
-        test_filter_conformance(&array.into_array());
+        test_filter_conformance(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
 
         // Test with nullable values
         let msp = PrimitiveArray::from_option_iter([Some(10i64), None, Some(30), Some(40), None])
             .into_array();
 
         let decimal_dtype = DecimalDType::new(18, 4);
         let array = DecimalByteParts::try_new(msp, decimal_dtype).unwrap();
-        test_filter_conformance(&array.into_array());
+        test_filter_conformance(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }

encodings/experimental/onpair/src/array.rs

@@ -475,14 +475,12 @@ impl VTable for OnPair {
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<()> {
         let Some(builder) = builder.as_any_mut().downcast_mut::<VarBinViewBuilder>() else {
-            builder.extend_from_array(
-                &array
-                    .array()
-                    .clone()
-                    .execute::<Canonical>(ctx)?
-                    .into_array(),
-            );
-            return Ok(());
+            return array
+                .array()
+                .clone()
+                .execute::<Canonical>(ctx)?
+                .into_array()
+                .append_to_builder(builder, ctx);
         };
 
         let next_buffer_index = builder.completed_block_count() + u32::from(builder.in_progress());

encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs

@@ -521,7 +521,7 @@ mod test {
 
         let mut primitive_builder =
             PrimitiveBuilder::<i32>::with_capacity(chunked.dtype().nullability(), 10 * 100);
-        primitive_builder.extend_from_array(&chunked);
+        chunked.append_to_builder(&mut primitive_builder, &mut ctx)?;
         let ca_into = primitive_builder.finish();
 
         assert_arrays_eq!(into_ca, ca_into, &mut ctx);

encodings/fastlanes/src/bitpacking/compute/cast.rs

@@ -266,6 +266,6 @@ mod tests {
     #[case(bp(&buffer![0u32, 1000, 2000, 3000, 4000].into_array(), 12))]
     #[case(bp(&PrimitiveArray::from_option_iter([Some(1u32), None, Some(7), Some(15), None]).into_array(), 4))]
     fn test_cast_bitpacked_conformance(#[case] array: BitPackedArray) {
-        test_cast_conformance(&array.into_array());
+        test_cast_conformance(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 }

encodings/fastlanes/src/bitpacking/compute/filter.rs

@@ -273,17 +273,17 @@ mod test {
         // Test with u8 values
         let unpacked = buffer![1u8, 2, 3, 4, 5].into_array();
         let bitpacked = BitPackedData::encode(&unpacked, 3, &mut ctx).unwrap();
-        test_filter_conformance(&bitpacked.into_array());
+        test_filter_conformance(&bitpacked.into_array(), &mut ctx);
 
         // Test with u32 values
         let unpacked = buffer![100u32, 200, 300, 400, 500].into_array();
         let bitpacked = BitPackedData::encode(&unpacked, 9, &mut ctx).unwrap();
-        test_filter_conformance(&bitpacked.into_array());
+        test_filter_conformance(&bitpacked.into_array(), &mut ctx);
 
         // Test with nullable values
         let unpacked = PrimitiveArray::from_option_iter([Some(1u16), None, Some(3), Some(4), None]);
         let bitpacked = BitPackedData::encode(&unpacked.into_array(), 3, &mut ctx).unwrap();
-        test_filter_conformance(&bitpacked.into_array());
+        test_filter_conformance(&bitpacked.into_array(), &mut ctx);
     }
 
     /// Regression test for signed integers with patches.

encodings/fastlanes/src/bitpacking/compute/take.rs

@@ -170,6 +170,7 @@ mod test {
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
+    use vortex_array::compute::conformance::take::test_take_conformance;
     use vortex_array::validity::Validity;
     use vortex_buffer::Buffer;
     use vortex_buffer::buffer;
@@ -328,7 +329,6 @@ mod test {
     #[case(bp(buffer![42u32].into_array(), 6))]
     #[case(bp(PrimitiveArray::from_iter((0..1024).map(|i| i as u32)).into_array(), 8))]
     fn test_take_bitpacked_conformance(#[case] bitpacked: BitPackedArray) {
-        use vortex_array::compute::conformance::take::test_take_conformance;
-        test_take_conformance(&bitpacked.into_array());
+        test_take_conformance(&bitpacked.into_array(), &mut SESSION.create_execution_ctx());
     }
 }

encodings/fastlanes/src/delta/compute/cast.rs

@@ -244,6 +244,9 @@ mod tests {
         let delta_array =
             Delta::try_from_primitive_array(&primitive, &mut SESSION.create_execution_ctx())
                 .unwrap();
-        test_cast_conformance(&delta_array.into_array());
+        test_cast_conformance(
+            &delta_array.into_array(),
+            &mut SESSION.create_execution_ctx(),
+        );
     }
 }

encodings/fastlanes/src/for/compute/cast.rs

@@ -118,6 +118,6 @@ mod tests {
         Scalar::from(-100i32)
     ))]
     fn test_cast_for_conformance(#[case] array: FoRArray) {
-        test_cast_conformance(&array.into_array());
+        test_cast_conformance(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 }

encodings/fastlanes/src/for/compute/mod.rs

@@ -49,8 +49,11 @@ mod test {
     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;
@@ -68,18 +71,27 @@ mod test {
             buffer![100i32, 101, 102, 103, 104].into_array(),
             Scalar::from(100i32),
         );
-        test_filter_conformance(&for_array.into_array());
+        test_filter_conformance(
+            &for_array.into_array(),
+            &mut array_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());
+        test_filter_conformance(
+            &for_array.into_array(),
+            &mut array_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());
+        test_filter_conformance(
+            &for_array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 
     #[rstest]
@@ -92,8 +104,10 @@ 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) {
-        use vortex_array::compute::conformance::take::test_take_conformance;
-        test_take_conformance(&for_array.into_array());
+        test_take_conformance(
+            &for_array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
 

encodings/fastlanes/src/rle/compute/cast.rs

@@ -162,6 +162,6 @@ mod tests {
     fn test_cast_rle_conformance(#[case] primitive: PrimitiveArray) {
         let mut ctx = SESSION.create_execution_ctx();
         let rle_array = rle(&primitive, &mut ctx);
-        test_cast_conformance(&rle_array.into_array());
+        test_cast_conformance(&rle_array.into_array(), &mut ctx);
     }
 }