Remove TypedArray, make InnerArrayData non-pub (#1378)

Also, converts `.clone().into_array()` -> `.to_array()` and removes From
impl with hidden clone.


FLUP: look at all the `SomeArray::try_from(xxx.clone())` !!! To remove
in #1377

Author: gatesn

bench-vortex/benches/compress_noci.rs

@@ -104,7 +104,7 @@ fn parquet_decompress_read(buf: bytes::Bytes) -> usize {
 }
 
 fn parquet_compressed_written_size(array: &ArrayData, compression: Compression) -> usize {
-    let chunked = ChunkedArray::try_from(array).unwrap();
+    let chunked = ChunkedArray::try_from(array.clone()).unwrap();
     let (batches, schema) = chunked_to_vec_record_batch(chunked);
     parquet_compress_write(batches, schema, compression, &mut Vec::new())
 }
@@ -216,7 +216,7 @@ fn benchmark_compress<F, U>(
         measurement_time.map(|t| group.measurement_time(t));
 
         group.bench_function(bench_name, |b| {
-            let chunked = ChunkedArray::try_from(uncompressed.as_ref()).unwrap();
+            let chunked = ChunkedArray::try_from(uncompressed.as_ref().clone()).unwrap();
             let (batches, schema) = chunked_to_vec_record_batch(chunked);
 
             b.iter_with_large_drop(|| {
@@ -258,7 +258,7 @@ fn benchmark_compress<F, U>(
         measurement_time.map(|t| group.measurement_time(t));
 
         let buffer = LazyCell::new(|| {
-            let chunked = ChunkedArray::try_from(uncompressed.as_ref()).unwrap();
+            let chunked = ChunkedArray::try_from(uncompressed.as_ref().clone()).unwrap();
             let (batches, schema) = chunked_to_vec_record_batch(chunked);
             let mut buf = Vec::new();
             parquet_compress_write(

bench-vortex/benches/compressor_throughput.rs

@@ -28,7 +28,7 @@ use vortex::sampling_compressor::compressors::CompressorRef;
 use vortex::sampling_compressor::SamplingCompressor;
 use vortex::scalar::Scalar;
 use vortex::validity::Validity;
-use vortex::{IntoArrayData as _, IntoCanonical};
+use vortex::{IntoArrayData as _, IntoCanonical, ToArrayData};
 
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
@@ -118,19 +118,17 @@ fn strings(c: &mut Criterion) {
 
     let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
     let (codes, values) = dict_encode_varbinview(&varbinview_arr);
-    group.throughput(Throughput::Bytes(
-        varbinview_arr.clone().into_array().nbytes() as u64,
-    ));
+    group.throughput(Throughput::Bytes(varbinview_arr.to_array().nbytes() as u64));
     group.bench_function("dict_decode_varbinview", |b| {
         b.iter_batched(
-            || DictArray::try_new(codes.clone().into_array(), values.clone().into_array()).unwrap(),
+            || DictArray::try_new(codes.to_array(), values.to_array()).unwrap(),
             |dict_arr| black_box(dict_arr.into_canonical().unwrap()),
             BatchSize::SmallInput,
         );
     });
 
-    let fsst_compressor = fsst_train_compressor(&varbinview_arr.clone().into_array()).unwrap();
-    let fsst_array = fsst_compress(&varbinview_arr.clone().into_array(), &fsst_compressor).unwrap();
+    let fsst_compressor = fsst_train_compressor(&varbinview_arr.to_array()).unwrap();
+    let fsst_array = fsst_compress(&varbinview_arr.to_array(), &fsst_compressor).unwrap();
     group.bench_function("fsst_decompress_varbinview", |b| {
         b.iter_batched(
             || fsst_array.clone(),

encodings/alp/src/alp/compress.rs

@@ -82,7 +82,7 @@ fn patch_decoded(array: PrimitiveArray, patches: &ArrayData) -> VortexResult<Pri
     match patches.encoding().id() {
         Sparse::ID => {
             match_each_alp_float_ptype!(array.ptype(), |$T| {
-                let typed_patches = SparseArray::try_from(patches).unwrap();
+                let typed_patches = SparseArray::try_from(patches.clone()).unwrap();
                 let primitive_values = typed_patches.values().into_primitive()?;
                 array.patch(
                     &typed_patches.resolved_indices(),

encodings/bytebool/src/array.rs

@@ -1,5 +1,6 @@
 use std::fmt::{Debug, Display};
 use std::mem::ManuallyDrop;
+use std::sync::Arc;
 
 use arrow_buffer::BooleanBuffer;
 use serde::{Deserialize, Serialize};
@@ -9,9 +10,7 @@ use vortex_array::encoding::ids;
 use vortex_array::stats::StatsSet;
 use vortex_array::validity::{ArrayValidity, LogicalValidity, Validity, ValidityMetadata};
 use vortex_array::variants::{ArrayVariants, BoolArrayTrait};
-use vortex_array::{
-    impl_encoding, ArrayData, ArrayTrait, Canonical, IntoArrayData, IntoCanonical, TypedArray,
-};
+use vortex_array::{impl_encoding, ArrayData, ArrayTrait, Canonical, IntoArrayData, IntoCanonical};
 use vortex_buffer::Buffer;
 use vortex_dtype::DType;
 use vortex_error::{VortexExpect as _, VortexResult};
@@ -41,18 +40,18 @@ impl ByteBoolArray {
     pub fn try_new(buffer: Buffer, validity: Validity) -> VortexResult<Self> {
         let length = buffer.len();
 
-        let typed = TypedArray::try_from_parts(
+        ArrayData::try_new_owned(
+            &ByteBoolEncoding,
             DType::Bool(validity.nullability()),
             length,
-            ByteBoolMetadata {
+            Arc::new(ByteBoolMetadata {
                 validity: validity.to_metadata(length)?,
-            },
+            }),
             Some(buffer),
             validity.into_array().into_iter().collect::<Vec<_>>().into(),
             StatsSet::default(),
-        )?;
-
-        Ok(typed.into())
+        )?
+        .try_into()
     }
 
     pub fn try_from_vec<V: Into<Validity>>(data: Vec<bool>, validity: V) -> VortexResult<Self> {

encodings/bytebool/src/compute.rs

@@ -3,7 +3,7 @@ use vortex_array::compute::unary::{FillForwardFn, ScalarAtFn};
 use vortex_array::compute::{ArrayCompute, SliceFn, TakeFn, TakeOptions};
 use vortex_array::validity::{ArrayValidity, Validity};
 use vortex_array::variants::PrimitiveArrayTrait;
-use vortex_array::{ArrayDType, ArrayData, IntoArrayData, IntoArrayVariant};
+use vortex_array::{ArrayDType, ArrayData, IntoArrayData, IntoArrayVariant, ToArrayData};
 use vortex_dtype::{match_each_integer_ptype, Nullability};
 use vortex_error::{vortex_err, VortexResult};
 use vortex_scalar::Scalar;
@@ -97,7 +97,7 @@ impl FillForwardFn for ByteBoolArray {
     fn fill_forward(&self) -> VortexResult<ArrayData> {
         let validity = self.logical_validity();
         if self.dtype().nullability() == Nullability::NonNullable {
-            return Ok(self.clone().into());
+            return Ok(self.to_array());
         }
         // all valid, but we need to convert to non-nullable
         if validity.all_valid() {

encodings/datetime-parts/src/compute.rs

@@ -132,7 +132,7 @@ pub fn decode_to_temporal(array: &DateTimePartsArray) -> VortexResult<TemporalAr
 mod test {
     use vortex_array::array::{PrimitiveArray, TemporalArray};
     use vortex_array::validity::Validity;
-    use vortex_array::{IntoArrayData, IntoArrayVariant};
+    use vortex_array::{IntoArrayVariant, ToArrayData};
     use vortex_datetime_dtype::TimeUnit;
     use vortex_dtype::DType;
 
@@ -158,7 +158,7 @@ mod test {
         assert_eq!(raw_millis.validity(), validity);
 
         let temporal_array = TemporalArray::new_timestamp(
-            raw_millis.clone().into_array(),
+            raw_millis.to_array(),
             TimeUnit::Ms,
             Some("UTC".to_string()),
         );

encodings/dict/benches/dict_compress.rs

@@ -5,7 +5,7 @@ use rand::distributions::{Alphanumeric, Uniform};
 use rand::prelude::SliceRandom;
 use rand::{thread_rng, Rng};
 use vortex_array::array::{PrimitiveArray, VarBinArray, VarBinViewArray};
-use vortex_array::{ArrayTrait, IntoArrayData as _, IntoCanonical as _};
+use vortex_array::{ArrayTrait, IntoCanonical as _, ToArrayData};
 use vortex_dict::{dict_encode_primitive, dict_encode_varbin, dict_encode_varbinview, DictArray};
 
 fn gen_primitive_dict(len: usize, uniqueness: f64) -> PrimitiveArray {
@@ -64,7 +64,7 @@ fn dict_decode(c: &mut Criterion) {
     group.throughput(Throughput::Bytes(primitive_arr.nbytes() as u64));
     group.bench_function("dict_decode_primitives", |b| {
         b.iter_batched(
-            || DictArray::try_new(codes.clone().into_array(), values.clone().into_array()).unwrap(),
+            || DictArray::try_new(codes.to_array(), values.to_array()).unwrap(),
             |dict_arr| black_box(dict_arr.into_canonical().unwrap()),
             BatchSize::SmallInput,
         );
@@ -75,7 +75,7 @@ fn dict_decode(c: &mut Criterion) {
     group.throughput(Throughput::Bytes(varbin_arr.nbytes() as u64));
     group.bench_function("dict_decode_varbin", |b| {
         b.iter_batched(
-            || DictArray::try_new(codes.clone().into_array(), values.clone().into_array()).unwrap(),
+            || DictArray::try_new(codes.to_array(), values.to_array()).unwrap(),
             |dict_arr| black_box(dict_arr.into_canonical().unwrap()),
             BatchSize::SmallInput,
         );
@@ -86,7 +86,7 @@ fn dict_decode(c: &mut Criterion) {
     group.throughput(Throughput::Bytes(varbin_arr.nbytes() as u64));
     group.bench_function("dict_decode_varbinview", |b| {
         b.iter_batched(
-            || DictArray::try_new(codes.clone().into_array(), values.clone().into_array()).unwrap(),
+            || DictArray::try_new(codes.to_array(), values.to_array()).unwrap(),
             |dict_arr| black_box(dict_arr.into_canonical().unwrap()),
             BatchSize::SmallInput,
         );

encodings/fastlanes/src/bitpacking/compress.rs

@@ -193,7 +193,7 @@ fn patch_unpacked(array: PrimitiveArray, patches: &ArrayData) -> VortexResult<Pr
     match patches.encoding().id() {
         Sparse::ID => {
             match_each_integer_ptype!(array.ptype(), |$T| {
-                let typed_patches = SparseArray::try_from(patches).unwrap();
+                let typed_patches = SparseArray::try_from(patches.clone()).unwrap();
                 let primitive_values = typed_patches.values().into_primitive()?;
                 array.patch(
                     &typed_patches.resolved_indices(),

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

@@ -29,7 +29,7 @@ impl SliceFn for BitPackedArray {
                 .filter(|a| {
                     // If the sliced patch_indices is empty, we should not propagate the patches.
                     // There may be other logic that depends on Some(patches) indicating non-empty.
-                    !SparseArray::try_from(a)
+                    !SparseArray::try_from(a.clone())
                         .vortex_expect("BitPackedArray must encode patches as SparseArray")
                         .indices()
                         .is_empty()

encodings/fastlanes/src/bitpacking/mod.rs

@@ -1,4 +1,5 @@
 use std::fmt::{Debug, Display};
+use std::sync::Arc;
 
 use ::serde::{Deserialize, Serialize};
 pub use compress::*;
@@ -9,9 +10,7 @@ use vortex_array::encoding::ids;
 use vortex_array::stats::{ArrayStatisticsCompute, StatsSet};
 use vortex_array::validity::{ArrayValidity, LogicalValidity, Validity, ValidityMetadata};
 use vortex_array::variants::{ArrayVariants, PrimitiveArrayTrait};
-use vortex_array::{
-    impl_encoding, ArrayDType, ArrayData, ArrayTrait, Canonical, IntoCanonical, TypedArray,
-};
+use vortex_array::{impl_encoding, ArrayDType, ArrayData, ArrayTrait, Canonical, IntoCanonical};
 use vortex_buffer::Buffer;
 use vortex_dtype::{DType, NativePType, Nullability, PType};
 use vortex_error::{vortex_bail, vortex_err, VortexExpect as _, VortexResult};
@@ -97,7 +96,7 @@ impl BitPackedArray {
                 )
             }
 
-            if SparseArray::try_from(parray)?.indices().is_empty() {
+            if SparseArray::try_from(parray.clone())?.indices().is_empty() {
                 vortex_bail!("cannot construct BitPackedArray using patches without indices");
             }
         }
@@ -117,16 +116,16 @@ impl BitPackedArray {
             children.push(a)
         }
 
-        Ok(Self {
-            typed: TypedArray::try_from_parts(
-                dtype,
-                length,
-                metadata,
-                Some(packed),
-                children.into(),
-                StatsSet::default(),
-            )?,
-        })
+        ArrayData::try_new_owned(
+            &BitPackedEncoding,
+            dtype,
+            length,
+            Arc::new(metadata),
+            Some(packed),
+            children.into(),
+            StatsSet::default(),
+        )?
+        .try_into()
     }
 
     #[inline]
@@ -188,7 +187,7 @@ impl BitPackedArray {
     }
 
     pub fn encode(array: &ArrayData, bit_width: u8) -> VortexResult<Self> {
-        if let Ok(parray) = PrimitiveArray::try_from(array) {
+        if let Ok(parray) = PrimitiveArray::try_from(array.clone()) {
             bitpack_encode(parray, bit_width)
         } else {
             vortex_bail!("Bitpacking can only encode primitive arrays");