Remove AsContiguousFn

bench-vortex/benches/compress_benchmark.rs

@@ -7,7 +7,7 @@ use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 fn vortex_compress_taxi(c: &mut Criterion) {
     taxi_data_parquet();
-    let mut group = c.benchmark_group("end to end");
+    let mut group = c.benchmark_group("end to end - taxi");
     group.sample_size(10);
     group.bench_function("compress", |b| b.iter(|| black_box(compress_taxi_data())));
     group.finish()
@@ -16,7 +16,7 @@ fn vortex_compress_taxi(c: &mut Criterion) {
 fn vortex_compress_medicare1(c: &mut Criterion) {
     let dataset = BenchmarkDatasets::PBI(Medicare1);
     dataset.as_uncompressed();
-    let mut group = c.benchmark_group("end to end");
+    let mut group = c.benchmark_group("end to end - medicare");
     group.sample_size(10);
     group.bench_function("compress", |b| {
         b.iter(|| black_box(dataset.compress_to_vortex()))

vortex-alp/src/compute.rs

@@ -1,16 +1,13 @@
-use vortex::compute::as_contiguous::AsContiguousFn;
 use vortex::compute::scalar_at::{scalar_at, ScalarAtFn};
 use vortex::compute::slice::{slice, SliceFn};
 use vortex::compute::take::{take, TakeFn};
 use vortex::compute::ArrayCompute;
-use vortex::{impl_default_as_contiguous_fn, Array, ArrayDType, IntoArray};
+use vortex::{Array, ArrayDType, IntoArray};
 use vortex_error::VortexResult;
 use vortex_scalar::Scalar;
 
 use crate::{match_each_alp_float_ptype, ALPArray};
 
-impl_default_as_contiguous_fn!(ALPArray);
-
 impl ArrayCompute for ALPArray {
     fn scalar_at(&self) -> Option<&dyn ScalarAtFn> {
         Some(self)
@@ -23,10 +20,6 @@ impl ArrayCompute for ALPArray {
     fn take(&self) -> Option<&dyn TakeFn> {
         Some(self)
     }
-
-    fn as_contiguous(&self) -> Option<&dyn AsContiguousFn> {
-        Some(self)
-    }
 }
 
 impl ScalarAtFn for ALPArray {
@@ -68,33 +61,3 @@ impl SliceFn for ALPArray {
         .into_array())
     }
 }
-
-#[cfg(test)]
-mod test {
-    use vortex::array::primitive::PrimitiveArray;
-    use vortex::compute::as_contiguous::AsContiguousFn;
-    use vortex::compute::scalar_at::scalar_at;
-    use vortex::validity::Validity;
-    use vortex::IntoArray;
-
-    use crate::ALPArray;
-
-    #[test]
-    fn test_as_contiguous() {
-        let values = vec![1.0, 2.0, 3.0];
-        let primitives = PrimitiveArray::from_vec(values, Validity::NonNullable);
-        let encoded = ALPArray::encode(primitives.into_array()).unwrap();
-        let alp = ALPArray::try_from(&encoded).unwrap();
-
-        let flat = alp.as_contiguous(&[encoded]).unwrap();
-
-        let a: f64 = scalar_at(&flat, 0).unwrap().try_into().unwrap();
-        let b: f64 = scalar_at(&flat, 1).unwrap().try_into().unwrap();
-
-        let c: f64 = scalar_at(&flat, 2).unwrap().try_into().unwrap();
-
-        assert_eq!(a, 1.0);
-        assert_eq!(b, 2.0);
-        assert_eq!(c, 3.0);
-    }
-}

vortex-array/src/array/bool/compute/mod.rs

@@ -1,6 +1,5 @@
 use crate::array::bool::BoolArray;
 use crate::compute::as_arrow::AsArrowArray;
-use crate::compute::as_contiguous::AsContiguousFn;
 use crate::compute::compare::CompareFn;
 use crate::compute::fill::FillForwardFn;
 use crate::compute::scalar_at::ScalarAtFn;
@@ -9,7 +8,6 @@ use crate::compute::take::TakeFn;
 use crate::compute::ArrayCompute;
 
 mod as_arrow;
-mod as_contiguous;
 mod compare;
 mod fill;
 mod flatten;
@@ -22,10 +20,6 @@ impl ArrayCompute for BoolArray {
         Some(self)
     }
 
-    fn as_contiguous(&self) -> Option<&dyn AsContiguousFn> {
-        Some(self)
-    }
-
     fn compare(&self) -> Option<&dyn CompareFn> {
         Some(self)
     }

vortex-array/src/array/chunked/compute/mod.rs

@@ -2,23 +2,21 @@ use vortex_error::VortexResult;
 use vortex_scalar::Scalar;
 
 use crate::array::chunked::ChunkedArray;
-use crate::compute::as_contiguous::{as_contiguous, AsContiguousFn};
 use crate::compute::scalar_at::{scalar_at, ScalarAtFn};
 use crate::compute::scalar_subtract::SubtractScalarFn;
 use crate::compute::slice::SliceFn;
 use crate::compute::take::TakeFn;
 use crate::compute::ArrayCompute;
-use crate::Array;
 
 mod slice;
 mod take;
 
 impl ArrayCompute for ChunkedArray {
-    fn as_contiguous(&self) -> Option<&dyn AsContiguousFn> {
+    fn scalar_at(&self) -> Option<&dyn ScalarAtFn> {
         Some(self)
     }
 
-    fn scalar_at(&self) -> Option<&dyn ScalarAtFn> {
+    fn subtract_scalar(&self) -> Option<&dyn SubtractScalarFn> {
         Some(self)
     }
 
@@ -29,23 +27,6 @@ impl ArrayCompute for ChunkedArray {
     fn take(&self) -> Option<&dyn TakeFn> {
         Some(self)
     }
-
-    fn subtract_scalar(&self) -> Option<&dyn SubtractScalarFn> {
-        Some(self)
-    }
-}
-
-impl AsContiguousFn for ChunkedArray {
-    fn as_contiguous(&self, arrays: &[Array]) -> VortexResult<Array> {
-        // Combine all the chunks into one, then call as_contiguous again.
-        let mut chunks = Vec::with_capacity(self.nchunks());
-        for array in arrays {
-            for chunk in Self::try_from(array).unwrap().chunks() {
-                chunks.push(chunk);
-            }
-        }
-        as_contiguous(&chunks)
-    }
 }
 
 impl ScalarAtFn for ChunkedArray {

vortex-array/src/array/chunked/compute/take.rs

@@ -52,10 +52,7 @@ impl TakeFn for ChunkedArray {
 
 #[cfg(test)]
 mod test {
-    use itertools::Itertools;
-
     use crate::array::chunked::ChunkedArray;
-    use crate::compute::as_contiguous::as_contiguous;
     use crate::compute::take::take;
     use crate::{ArrayDType, ArrayTrait, AsArray, IntoArray};
 
@@ -68,14 +65,11 @@ mod test {
         assert_eq!(arr.len(), 9);
         let indices = vec![0, 0, 6, 4].into_array();
 
-        let result = as_contiguous(
-            &ChunkedArray::try_from(take(arr.as_array_ref(), &indices).unwrap())
-                .unwrap()
-                .chunks()
-                .collect_vec(),
-        )
-        .unwrap()
-        .into_primitive();
+        let result = &ChunkedArray::try_from(take(arr.as_array_ref(), &indices).unwrap())
+            .unwrap()
+            .into_array()
+            .flatten_primitive()
+            .unwrap();
         assert_eq!(result.typed_data::<i32>(), &[1, 1, 1, 2]);
     }
 }