diff --git a/Cargo.toml b/Cargo.toml index fc302ad1b92..6bb0413546a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -349,6 +349,7 @@ needless_range_loop = "allow" or_fun_call = "deny" panic = "deny" # panic_in_result_fn = "deny" -- we cannot disable this for tests to use assertions +clone_on_ref_ptr = "deny" redundant_clone = "deny" same_name_method = "deny" tests_outside_test_module = "deny" diff --git a/benchmarks/compress-bench/src/parquet.rs b/benchmarks/compress-bench/src/parquet.rs index 0a4e9105600..aaf64f81c94 100644 --- a/benchmarks/compress-bench/src/parquet.rs +++ b/benchmarks/compress-bench/src/parquet.rs @@ -53,7 +53,7 @@ impl Compressor for ParquetCompressor { // Read the input parquet file let file = File::open(parquet_path)?; let builder = ParquetRecordBatchReaderBuilder::try_new(file)?; - let schema = builder.schema().clone(); + let schema = Arc::clone(builder.schema()); let reader = builder.build()?; let batches: Vec = reader.collect::, _>>()?; @@ -69,7 +69,7 @@ impl Compressor for ParquetCompressor { // First compress to get the bytes we'll decompress let file = File::open(parquet_path)?; let builder = ParquetRecordBatchReaderBuilder::try_new(file)?; - let schema = builder.schema().clone(); + let schema = Arc::clone(builder.schema()); let reader = builder.build()?; let batches: Vec = reader.collect::, _>>()?; diff --git a/benchmarks/datafusion-bench/src/lib.rs b/benchmarks/datafusion-bench/src/lib.rs index 43b86331e9f..94ea053ba8f 100644 --- a/benchmarks/datafusion-bench/src/lib.rs +++ b/benchmarks/datafusion-bench/src/lib.rs @@ -81,8 +81,10 @@ pub fn make_object_store( .with_bucket_name(bucket_name) .build()?, ); - session - .register_object_store(&Url::parse(&format!("s3://{bucket_name}/"))?, s3.clone()); + session.register_object_store( + &Url::parse(&format!("s3://{bucket_name}/"))?, + Arc::::clone(&s3), + ); Ok(s3) } "gs" => { @@ -92,13 +94,16 @@ pub fn make_object_store( .with_bucket_name(bucket_name) .build()?, ); - session - .register_object_store(&Url::parse(&format!("gs://{bucket_name}/"))?, gcs.clone()); + session.register_object_store( + &Url::parse(&format!("gs://{bucket_name}/"))?, + Arc::::clone(&gcs), + ); Ok(gcs) } _ => { let fs = Arc::new(LocalFileSystem::default()); - session.register_object_store(&Url::parse("file:/")?, fs.clone()); + session + .register_object_store(&Url::parse("file:/")?, Arc::::clone(&fs)); Ok(fs) } } diff --git a/benchmarks/datafusion-bench/src/main.rs b/benchmarks/datafusion-bench/src/main.rs index 942f52f842e..8d85dd8f4eb 100644 --- a/benchmarks/datafusion-bench/src/main.rs +++ b/benchmarks/datafusion-bench/src/main.rs @@ -203,7 +203,7 @@ async fn main() -> anyhow::Result<()> { .iter() .any(|(idx, f, _)| *idx == query_idx && *f == *format) { - plans_mut.push((query_idx, *format, plan.clone())); + plans_mut.push((query_idx, *format, Arc::clone(&plan))); } } @@ -252,7 +252,7 @@ async fn register_benchmark_tables( let pattern = benchmark.pattern(table.name, format); let table_url = ListingTableUrl::try_new(benchmark_base.clone(), pattern)?; - let mut listing_options = ListingOptions::new(file_format.clone()) + let mut listing_options = ListingOptions::new(Arc::clone(&file_format)) .with_session_config_options(session.state().config()); if benchmark.dataset_name() == "polarsignals" && format == Format::Parquet { // Work around a DataFusion bug (fixed in 53.0.0) where the @@ -304,8 +304,10 @@ async fn register_v2_tables( .runtime_env() .object_store(table_url.object_store())?; - let fs: vortex::io::filesystem::FileSystemRef = - Arc::new(ObjectStoreFileSystem::new(store.clone(), SESSION.handle())); + let fs: vortex::io::filesystem::FileSystemRef = Arc::new(ObjectStoreFileSystem::new( + Arc::clone(&store), + SESSION.handle(), + )); let base_prefix = benchmark_base.path().trim_start_matches('/').to_string(); let fs = fs.with_prefix(base_prefix); @@ -416,7 +418,7 @@ pub async fn execute_query( .create_physical_plan() .with_labelset(get_labelset_from_global()) .await?; - let result = collect(plan.clone(), task_ctx) + let result = collect(Arc::clone(&plan), task_ctx) .with_labelset(get_labelset_from_global()) .await?; diff --git a/benchmarks/lance-bench/src/compress.rs b/benchmarks/lance-bench/src/compress.rs index 93891ec5555..a7732730ef7 100644 --- a/benchmarks/lance-bench/src/compress.rs +++ b/benchmarks/lance-bench/src/compress.rs @@ -4,6 +4,7 @@ use std::fs; use std::fs::File; use std::path::Path; +use std::sync::Arc; use std::time::Duration; use std::time::Instant; @@ -92,7 +93,7 @@ impl Compressor for LanceCompressor { // Read the input parquet file let file = File::open(parquet_path)?; let builder = ParquetRecordBatchReaderBuilder::try_new(file)?; - let schema = builder.schema().clone(); + let schema = Arc::clone(builder.schema()); let reader = builder.build()?; let batches: Vec = reader.collect::, _>>()?; @@ -131,7 +132,7 @@ impl Compressor for LanceCompressor { // First compress to get the Lance dataset let file = File::open(parquet_path)?; let builder = ParquetRecordBatchReaderBuilder::try_new(file)?; - let schema = builder.schema().clone(); + let schema = Arc::clone(builder.schema()); let reader = builder.build()?; let batches: Vec = reader.collect::, _>>()?; diff --git a/benchmarks/lance-bench/src/convert.rs b/benchmarks/lance-bench/src/convert.rs index 0da159b25e4..ac1db099953 100644 --- a/benchmarks/lance-bench/src/convert.rs +++ b/benchmarks/lance-bench/src/convert.rs @@ -84,7 +84,7 @@ impl Iterator for ParquetFilesIterator { impl RecordBatchReader for ParquetFilesIterator { fn schema(&self) -> SchemaRef { - self.schema.clone() + Arc::clone(&self.schema) } } @@ -161,7 +161,7 @@ pub async fn convert_parquet_to_lance<'p>( // Get schema from the first Parquet file let first_file = File::open(&parquet_files[0])?; let first_builder = ParquetRecordBatchReaderBuilder::try_new(first_file)?; - let schema = first_builder.schema().clone(); + let schema = Arc::clone(first_builder.schema()); // Create a streaming iterator that reads from all Parquet files let batch_iter = ParquetFilesIterator::new(parquet_files, schema)?; @@ -237,7 +237,7 @@ pub fn convert_utf8view_batch(batch: RecordBatch) -> anyhow::Result // Cast Utf8View to Utf8. cast(column, &DataType::Utf8)? } else { - column.clone() + Arc::clone(column) }; new_columns.push(new_column); } @@ -277,6 +277,6 @@ impl Iterator for ConvertingParquetFilesIterator { impl RecordBatchReader for ConvertingParquetFilesIterator { fn schema(&self) -> SchemaRef { - self.converted_schema.clone() + Arc::clone(&self.converted_schema) } } diff --git a/encodings/fastlanes/src/bitpacking/compute/filter.rs b/encodings/fastlanes/src/bitpacking/compute/filter.rs index ec2e7f6ea68..aa3ca07d0b0 100644 --- a/encodings/fastlanes/src/bitpacking/compute/filter.rs +++ b/encodings/fastlanes/src/bitpacking/compute/filter.rs @@ -82,7 +82,7 @@ impl FilterKernel for BitPacked { let patches = array .patches() - .map(|patches| patches.filter(&Mask::Values(values.clone()), ctx)) + .map(|patches| patches.filter(&Mask::Values(Arc::clone(values)), ctx)) .transpose()? .flatten(); @@ -112,7 +112,9 @@ fn filter_primitive_without_patches( selection: &Arc, ) -> VortexResult<(Buffer, Validity)> { let values = filter_with_indices(array.data(), selection.indices()); - let validity = array.validity()?.filter(&Mask::Values(selection.clone()))?; + let validity = array + .validity()? + .filter(&Mask::Values(Arc::clone(selection)))?; Ok((values.freeze(), validity)) } diff --git a/encodings/sparse/src/canonical.rs b/encodings/sparse/src/canonical.rs index 1d42ccf5d15..c53fd8989e8 100644 --- a/encodings/sparse/src/canonical.rs +++ b/encodings/sparse/src/canonical.rs @@ -113,7 +113,7 @@ pub(super) fn execute_sparse( execute_varbin(array, dtype.clone(), fill_value, ctx)? } DType::List(values_dtype, nullability) => { - execute_sparse_lists(array, values_dtype.clone(), *nullability, ctx)? + execute_sparse_lists(array, Arc::clone(values_dtype), *nullability, ctx)? } DType::FixedSizeList(.., nullability) => { execute_sparse_fixed_size_list(array, *nullability, ctx)? diff --git a/fuzz/src/array/fill_null.rs b/fuzz/src/array/fill_null.rs index 1a66d6f9773..21430ce2b4d 100644 --- a/fuzz/src/array/fill_null.rs +++ b/fuzz/src/array/fill_null.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::Arc; + use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; @@ -221,7 +223,7 @@ fn fill_varbinview_array( if result_nullability == Nullability::Nullable { VarBinViewArray::new_handle( result.to_varbinview().views_handle().clone(), - result.to_varbinview().data_buffers().clone(), + Arc::clone(result.to_varbinview().data_buffers()), result.dtype().as_nullable(), result_nullability.into(), ) @@ -255,7 +257,7 @@ fn fill_varbinview_array( if result_nullability == Nullability::Nullable { VarBinViewArray::new_handle( result.to_varbinview().views_handle().clone(), - result.to_varbinview().data_buffers().clone(), + Arc::clone(result.to_varbinview().data_buffers()), result.dtype().as_nullable(), result_nullability.into(), ) diff --git a/fuzz/src/array/mask.rs b/fuzz/src/array/mask.rs index 7df7afcbe47..4c97200fa2d 100644 --- a/fuzz/src/array/mask.rs +++ b/fuzz/src/array/mask.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::Arc; + use vortex_array::ArrayRef; use vortex_array::Canonical; use vortex_array::IntoArray; @@ -86,7 +88,7 @@ pub fn mask_canonical_array(canonical: Canonical, mask: &Mask) -> VortexResult()? { @@ -229,7 +229,7 @@ fn random_list_with_offset_type( ) -> Result { let array_length = chunk_len.unwrap_or(u.int_in_range(0..=20)?); - let mut builder = ListViewBuilder::::with_capacity(elem_dtype.clone(), null, 20, 10); + let mut builder = ListViewBuilder::::with_capacity(Arc::clone(elem_dtype), null, 20, 10); for _ in 0..array_length { if null == Nullability::Nullable && u.arbitrary::()? { @@ -255,7 +255,7 @@ fn random_list_scalar( let elems = (0..list_size) .map(|_| random_scalar(u, elem_dtype)) .collect::>>()?; - Ok(Scalar::list(elem_dtype.clone(), elems, null)) + Ok(Scalar::list(Arc::clone(elem_dtype), elems, null)) } fn random_string( diff --git a/vortex-array/src/arrays/filter/execute/mod.rs b/vortex-array/src/arrays/filter/execute/mod.rs index 8a364cc71b6..bcbf28c0d96 100644 --- a/vortex-array/src/arrays/filter/execute/mod.rs +++ b/vortex-array/src/arrays/filter/execute/mod.rs @@ -41,7 +41,7 @@ mod varbinview; /// Reconstruct a [`Mask`] from an [`Arc`]. fn values_to_mask(values: &Arc) -> Mask { - Mask::Values(values.clone()) + Mask::Values(Arc::clone(values)) } /// A helper function that lazily filters a [`Validity`] with selection mask values. diff --git a/vortex-array/src/arrays/list/compute/take.rs b/vortex-array/src/arrays/list/compute/take.rs index 0dfe49ef35d..841fd4ac45b 100644 --- a/vortex-array/src/arrays/list/compute/take.rs +++ b/vortex-array/src/arrays/list/compute/take.rs @@ -237,7 +237,7 @@ mod test { assert_eq!( result.scalar_at(0).unwrap(), Scalar::list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![0i32.into(), 5.into()], Nullability::Nullable ) @@ -249,7 +249,7 @@ mod test { assert_eq!( result.scalar_at(2).unwrap(), Scalar::list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![3i32.into()], Nullability::Nullable ) @@ -317,7 +317,7 @@ mod test { assert_eq!( result.scalar_at(0).unwrap(), Scalar::list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![3i32.into()], Nullability::NonNullable ) @@ -327,7 +327,7 @@ mod test { assert_eq!( result.scalar_at(1).unwrap(), Scalar::list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![0i32.into(), 5.into()], Nullability::NonNullable ) diff --git a/vortex-array/src/arrays/list/test_harness.rs b/vortex-array/src/arrays/list/test_harness.rs index 7ced1eb878f..42351484c19 100644 --- a/vortex-array/src/arrays/list/test_harness.rs +++ b/vortex-array/src/arrays/list/test_harness.rs @@ -28,7 +28,7 @@ impl ListArray { { let iter = iter.into_iter(); let mut builder = ListBuilder::::with_capacity( - dtype.clone(), + Arc::clone(&dtype), crate::dtype::Nullability::NonNullable, 2 * iter.size_hint().0, iter.size_hint().0, @@ -36,7 +36,7 @@ impl ListArray { for v in iter { let elem = Scalar::list( - dtype.clone(), + Arc::clone(&dtype), v.into_iter().map(|x| x.into()).collect_vec(), dtype.nullability(), ); @@ -55,7 +55,7 @@ impl ListArray { { let iter = iter.into_iter(); let mut builder = ListBuilder::::with_capacity( - dtype.clone(), + Arc::clone(&dtype), crate::dtype::Nullability::Nullable, 2 * iter.size_hint().0, iter.size_hint().0, @@ -64,7 +64,7 @@ impl ListArray { for v in iter { if let Some(v) = v { let elem = Scalar::list( - dtype.clone(), + Arc::clone(&dtype), v.into_iter().map(|x| x.into()).collect_vec(), dtype.nullability(), ); diff --git a/vortex-array/src/arrays/masked/execute.rs b/vortex-array/src/arrays/masked/execute.rs index f830d2525f9..4bc6449ead3 100644 --- a/vortex-array/src/arrays/masked/execute.rs +++ b/vortex-array/src/arrays/masked/execute.rs @@ -4,6 +4,7 @@ //! Execution logic for MaskedArray - applies a validity mask to canonical arrays. use std::ops::BitAnd; +use std::sync::Arc; use vortex_error::VortexResult; use vortex_mask::Mask; @@ -136,7 +137,7 @@ fn mask_validity_varbinview( Ok(unsafe { VarBinViewArray::new_handle_unchecked( array.views_handle().clone(), - array.data_buffers().clone(), + Arc::clone(array.data_buffers()), dtype, new_validity, ) diff --git a/vortex-array/src/arrays/varbinview/compute/cast.rs b/vortex-array/src/arrays/varbinview/compute/cast.rs index 3d5106f0a4a..a8e649f52e4 100644 --- a/vortex-array/src/arrays/varbinview/compute/cast.rs +++ b/vortex-array/src/arrays/varbinview/compute/cast.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::Arc; + use vortex_error::VortexResult; use crate::ArrayRef; @@ -28,7 +30,7 @@ impl CastReduce for VarBinView { Ok(Some( VarBinViewArray::new_handle_unchecked( array.views_handle().clone(), - array.data_buffers().clone(), + Arc::clone(array.data_buffers()), new_dtype, new_validity, ) diff --git a/vortex-array/src/arrays/varbinview/compute/mask.rs b/vortex-array/src/arrays/varbinview/compute/mask.rs index 95630d3fcd5..6172c42ab7d 100644 --- a/vortex-array/src/arrays/varbinview/compute/mask.rs +++ b/vortex-array/src/arrays/varbinview/compute/mask.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::Arc; + use vortex_error::VortexResult; use crate::ArrayRef; @@ -18,7 +20,7 @@ impl MaskReduce for VarBinView { Ok(Some( VarBinViewArray::new_handle_unchecked( array.views_handle().clone(), - array.data_buffers().clone(), + Arc::clone(array.data_buffers()), array.dtype().as_nullable(), array.validity()?.and(Validity::Array(mask.clone()))?, ) diff --git a/vortex-array/src/arrays/varbinview/compute/take.rs b/vortex-array/src/arrays/varbinview/compute/take.rs index 8dfc1dfc4b4..644465ecac3 100644 --- a/vortex-array/src/arrays/varbinview/compute/take.rs +++ b/vortex-array/src/arrays/varbinview/compute/take.rs @@ -2,6 +2,7 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::iter; +use std::sync::Arc; use num_traits::AsPrimitive; use vortex_buffer::Buffer; @@ -41,7 +42,7 @@ impl TakeExecute for VarBinView { Ok(Some( VarBinViewArray::new_handle_unchecked( BufferHandle::new_host(views_buffer.into_byte_buffer()), - array.data_buffers().clone(), + Arc::clone(array.data_buffers()), array .dtype() .union_nullability(indices.dtype().nullability()), diff --git a/vortex-array/src/arrow/convert.rs b/vortex-array/src/arrow/convert.rs index dce18c2872d..6eafa6033c5 100644 --- a/vortex-array/src/arrow/convert.rs +++ b/vortex-array/src/arrow/convert.rs @@ -1508,7 +1508,8 @@ mod tests { // Create a FixedSizeListArray with list_size=3 let field = Arc::new(Field::new("item", DataType::Int32, true)); let arrow_array = - ArrowFixedSizeListArray::try_new(field.clone(), 3, Arc::new(values), None).unwrap(); + ArrowFixedSizeListArray::try_new(Arc::clone(&field), 3, Arc::new(values), None) + .unwrap(); let vortex_array = ArrayRef::from_arrow(&arrow_array, false).unwrap(); assert_eq!(vortex_array.len(), 4); @@ -1574,7 +1575,7 @@ mod tests { let field = Arc::new(Field::new("item", DataType::Int32, true)); let arrow_array = GenericListViewArray::try_new( - field.clone(), + Arc::clone(&field), offsets.clone(), sizes.clone(), Arc::new(values.clone()), @@ -1600,7 +1601,7 @@ mod tests { arrow_buffer::NullBuffer::new(BooleanBuffer::from(vec![true, false, true, true])); let arrow_array_nullable = GenericListViewArray::try_new( - field.clone(), + Arc::clone(&field), offsets, sizes, Arc::new(values.clone()), diff --git a/vortex-array/src/arrow/executor/fixed_size_list.rs b/vortex-array/src/arrow/executor/fixed_size_list.rs index 47dde9fb264..7abea9aaa7a 100644 --- a/vortex-array/src/arrow/executor/fixed_size_list.rs +++ b/vortex-array/src/arrow/executor/fixed_size_list.rs @@ -57,7 +57,7 @@ fn list_to_list( Ok(Arc::new( arrow_array::FixedSizeListArray::try_new_with_length( - elements_field.clone(), + Arc::clone(elements_field), list_size, elements, null_buffer, diff --git a/vortex-array/src/arrow/executor/list.rs b/vortex-array/src/arrow/executor/list.rs index 302c4f7f892..285ad733cfb 100644 --- a/vortex-array/src/arrow/executor/list.rs +++ b/vortex-array/src/arrow/executor/list.rs @@ -109,7 +109,7 @@ fn list_to_list( // TODO(ngates): use new_unchecked when it is added to arrow-rs. Ok(Arc::new(GenericListArray::::new( - elements_field.clone(), + Arc::clone(elements_field), offsets, elements, null_buffer, @@ -129,7 +129,7 @@ fn list_view_zctl( .clone() .execute_arrow(Some(elements_field.data_type()), ctx)?; return Ok(Arc::new(GenericListArray::::new( - elements_field.clone(), + Arc::clone(elements_field), OffsetBuffer::new_empty(), elements, None, @@ -185,7 +185,7 @@ fn list_view_zctl( let null_buffer = to_arrow_null_buffer(validity, sizes.len(), ctx)?; Ok(Arc::new(GenericListArray::::new( - elements_field.clone(), + Arc::clone(elements_field), offsets.freeze().into_arrow_offset_buffer(), elements, null_buffer, diff --git a/vortex-array/src/arrow/executor/list_view.rs b/vortex-array/src/arrow/executor/list_view.rs index c3de7f303a3..bf6d0da0b8b 100644 --- a/vortex-array/src/arrow/executor/list_view.rs +++ b/vortex-array/src/arrow/executor/list_view.rs @@ -71,7 +71,7 @@ fn list_view_to_list_view( let null_buffer = to_arrow_null_buffer(validity, offsets.len(), ctx)?; Ok(Arc::new(GenericListViewArray::::new( - elements_field.clone(), + Arc::clone(elements_field), offsets, sizes, elements, diff --git a/vortex-array/src/builders/fixed_size_list.rs b/vortex-array/src/builders/fixed_size_list.rs index b951c0fc74b..f26281d5363 100644 --- a/vortex-array/src/builders/fixed_size_list.rs +++ b/vortex-array/src/builders/fixed_size_list.rs @@ -301,12 +301,13 @@ mod tests { #[test] fn test_values() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 0); + let mut builder = + FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 0); builder .append_value( Scalar::fixed_size_list( - dtype.clone(), + Arc::clone(&dtype), vec![1i32.into(), 2i32.into(), 3i32.into()], NonNullable, ) @@ -337,12 +338,14 @@ mod tests { fn test_degenerate_size_zero_non_nullable() { let dtype: Arc = Arc::new(I32.into()); let mut builder = - FixedSizeListBuilder::with_capacity(dtype.clone(), 0, NonNullable, 10000000); + FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 0, NonNullable, 10000000); // Append multiple "empty" lists. for _ in 0..100 { builder - .append_value(Scalar::fixed_size_list(dtype.clone(), vec![], NonNullable).as_list()) + .append_value( + Scalar::fixed_size_list(Arc::clone(&dtype), vec![], NonNullable).as_list(), + ) .unwrap(); } @@ -359,14 +362,15 @@ mod tests { fn test_degenerate_size_zero_nullable() { // Use nullable elements since we'll be appending nulls let dtype: Arc = Arc::new(DType::Primitive(I32, Nullable)); - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 0, Nullable, 10000000); + let mut builder = + FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 0, Nullable, 10000000); // Mix of null and non-null empty lists. for i in 0..100 { if i % 2 == 0 { builder .append_value( - Scalar::fixed_size_list(dtype.clone(), vec![], Nullable).as_list(), + Scalar::fixed_size_list(Arc::clone(&dtype), vec![], Nullable).as_list(), ) .unwrap(); } else { @@ -386,14 +390,15 @@ mod tests { fn test_capacity_growth() { let dtype: Arc = Arc::new(I32.into()); // Start with capacity 0. - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 2, NonNullable, 0); + let mut builder = + FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, NonNullable, 0); // Add more items than initial capacity. for i in 0..5 { builder .append_value( Scalar::fixed_size_list( - dtype.clone(), + Arc::clone(&dtype), vec![(i * 2).into(), (i * 2 + 1).into()], NonNullable, ) @@ -426,12 +431,16 @@ mod tests { #[test] fn test_nullable_lists_non_nullable_elements() { let dtype: Arc = Arc::new(DType::Primitive(I32, NonNullable)); - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 2, Nullable, 0); + let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0); builder .append_value( - Scalar::fixed_size_list(dtype.clone(), vec![1i32.into(), 2i32.into()], Nullable) - .as_list(), + Scalar::fixed_size_list( + Arc::clone(&dtype), + vec![1i32.into(), 2i32.into()], + Nullable, + ) + .as_list(), ) .unwrap(); @@ -473,12 +482,13 @@ mod tests { #[test] fn test_non_nullable_lists_nullable_elements() { let dtype: Arc = Arc::new(DType::Primitive(I32, Nullable)); - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 0); + let mut builder = + FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 0); builder .append_value( Scalar::fixed_size_list( - dtype.clone(), + Arc::clone(&dtype), vec![ Scalar::primitive(1i32, Nullable), Scalar::null(dtype.as_ref().clone()), @@ -608,7 +618,8 @@ mod tests { #[test] fn test_invalid_size_error() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 0); + let mut builder = + FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 0); // Try to append a list with wrong size. let result = builder.append_value( @@ -779,7 +790,8 @@ mod tests { 0, ); - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 0); + let mut builder = + FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 0); // Add some initial data. builder @@ -804,7 +816,7 @@ mod tests { fn test_mixed_operations() { // Use nullable elements since we'll be appending nulls let dtype: Arc = Arc::new(DType::Primitive(I32, Nullable)); - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 2, Nullable, 0); + let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0); // Mix of operations. builder @@ -887,16 +899,16 @@ mod tests { #[test] fn test_append_scalar() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 2, Nullable, 10); + let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 10); // Test appending a valid fixed-size list. let list_scalar1 = - Scalar::fixed_size_list(dtype.clone(), vec![1i32.into(), 2i32.into()], Nullable); + Scalar::fixed_size_list(Arc::clone(&dtype), vec![1i32.into(), 2i32.into()], Nullable); builder.append_scalar(&list_scalar1).unwrap(); // Test appending another list. let list_scalar2 = - Scalar::fixed_size_list(dtype.clone(), vec![3i32.into(), 4i32.into()], Nullable); + Scalar::fixed_size_list(Arc::clone(&dtype), vec![3i32.into(), 4i32.into()], Nullable); builder.append_scalar(&list_scalar2).unwrap(); // Test appending null via builder method (since fixed-size list null handling is special). @@ -955,7 +967,8 @@ mod tests { #[test] fn test_append_array_as_list() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 10); + let mut builder = + FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 10); // Append a primitive array as a single list entry. let arr1 = buffer![1i32, 2, 3].into_array(); @@ -965,7 +978,7 @@ mod tests { builder .append_value( Scalar::fixed_size_list( - dtype.clone(), + Arc::clone(&dtype), vec![10i32.into(), 11i32.into(), 12i32.into()], NonNullable, ) @@ -981,7 +994,7 @@ mod tests { builder .append_value( Scalar::fixed_size_list( - dtype.clone(), + Arc::clone(&dtype), vec![20i32.into(), 21i32.into(), 22i32.into()], NonNullable, ) @@ -1001,7 +1014,8 @@ mod tests { ); // Test dtype mismatch error. - let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 10); + let mut builder = + FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 10); let wrong_dtype_arr = buffer![1i64, 2, 3].into_array(); assert!(builder.append_array_as_list(&wrong_dtype_arr).is_err()); diff --git a/vortex-array/src/builders/list.rs b/vortex-array/src/builders/list.rs index 11253f92a3a..5eb6d12223b 100644 --- a/vortex-array/src/builders/list.rs +++ b/vortex-array/src/builders/list.rs @@ -345,12 +345,12 @@ mod tests { #[test] fn test_values() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = ListBuilder::::with_capacity(dtype.clone(), NonNullable, 0, 0); + let mut builder = ListBuilder::::with_capacity(Arc::clone(&dtype), NonNullable, 0, 0); builder .append_value( Scalar::list( - dtype.clone(), + Arc::clone(&dtype), vec![1i32.into(), 2i32.into(), 3i32.into()], NonNullable, ) @@ -381,7 +381,7 @@ mod tests { #[test] fn test_append_empty_list() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = ListBuilder::::with_capacity(dtype.clone(), NonNullable, 0, 0); + let mut builder = ListBuilder::::with_capacity(Arc::clone(&dtype), NonNullable, 0, 0); assert!( builder @@ -393,12 +393,12 @@ mod tests { #[test] fn test_nullable_values() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = ListBuilder::::with_capacity(dtype.clone(), Nullable, 0, 0); + let mut builder = ListBuilder::::with_capacity(Arc::clone(&dtype), Nullable, 0, 0); builder .append_value( Scalar::list( - dtype.clone(), + Arc::clone(&dtype), vec![1i32.into(), 2i32.into(), 3i32.into()], NonNullable, ) @@ -407,7 +407,7 @@ mod tests { .unwrap(); builder - .append_value(Scalar::list_empty(dtype.clone(), NonNullable).as_list()) + .append_value(Scalar::list_empty(Arc::clone(&dtype), NonNullable).as_list()) .unwrap(); builder @@ -535,22 +535,23 @@ mod tests { #[test] fn test_append_scalar() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = ListBuilder::::with_capacity(dtype.clone(), Nullable, 20, 10); + let mut builder = ListBuilder::::with_capacity(Arc::clone(&dtype), Nullable, 20, 10); // Test appending a valid list. - let list_scalar1 = Scalar::list(dtype.clone(), vec![1i32.into(), 2i32.into()], Nullable); + let list_scalar1 = + Scalar::list(Arc::clone(&dtype), vec![1i32.into(), 2i32.into()], Nullable); builder.append_scalar(&list_scalar1).unwrap(); // Test appending another list. let list_scalar2 = Scalar::list( - dtype.clone(), + Arc::clone(&dtype), vec![3i32.into(), 4i32.into(), 5i32.into()], Nullable, ); builder.append_scalar(&list_scalar2).unwrap(); // Test appending null value. - let null_scalar = Scalar::null(DType::List(dtype.clone(), Nullable)); + let null_scalar = Scalar::null(DType::List(Arc::clone(&dtype), Nullable)); builder.append_scalar(&null_scalar).unwrap(); let array = builder.finish_into_list(); @@ -611,7 +612,8 @@ mod tests { #[test] fn test_append_array_as_list() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = ListBuilder::::with_capacity(dtype.clone(), NonNullable, 20, 10); + let mut builder = + ListBuilder::::with_capacity(Arc::clone(&dtype), NonNullable, 20, 10); // Append a primitive array as a single list entry. let arr1 = buffer![1i32, 2, 3].into_array(); @@ -620,8 +622,12 @@ mod tests { // Interleave with a list scalar. builder .append_value( - Scalar::list(dtype.clone(), vec![10i32.into(), 11i32.into()], NonNullable) - .as_list(), + Scalar::list( + Arc::clone(&dtype), + vec![10i32.into(), 11i32.into()], + NonNullable, + ) + .as_list(), ) .unwrap(); @@ -635,7 +641,7 @@ mod tests { // Interleave with another list scalar (empty list). builder - .append_value(Scalar::list_empty(dtype.clone(), NonNullable).as_list()) + .append_value(Scalar::list_empty(Arc::clone(&dtype), NonNullable).as_list()) .unwrap(); let list = builder.finish_into_list(); diff --git a/vortex-array/src/builders/listview.rs b/vortex-array/src/builders/listview.rs index 714276d0660..b339dc430f7 100644 --- a/vortex-array/src/builders/listview.rs +++ b/vortex-array/src/builders/listview.rs @@ -456,13 +456,14 @@ mod tests { #[test] fn test_basic_append_and_nulls() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = ListViewBuilder::::with_capacity(dtype.clone(), Nullable, 0, 0); + let mut builder = + ListViewBuilder::::with_capacity(Arc::clone(&dtype), Nullable, 0, 0); // Append a regular list. builder .append_value( Scalar::list( - dtype.clone(), + Arc::clone(&dtype), vec![1i32.into(), 2i32.into(), 3i32.into()], NonNullable, ) @@ -472,7 +473,7 @@ mod tests { // Append an empty list. builder - .append_value(Scalar::list_empty(dtype.clone(), NonNullable).as_list()) + .append_value(Scalar::list_empty(Arc::clone(&dtype), NonNullable).as_list()) .unwrap(); // Append a null list. @@ -518,11 +519,16 @@ mod tests { // Test u32 offsets with u8 sizes. let dtype: Arc = Arc::new(I32.into()); let mut builder = - ListViewBuilder::::with_capacity(dtype.clone(), NonNullable, 0, 0); + ListViewBuilder::::with_capacity(Arc::clone(&dtype), NonNullable, 0, 0); builder .append_value( - Scalar::list(dtype.clone(), vec![1i32.into(), 2i32.into()], NonNullable).as_list(), + Scalar::list( + Arc::clone(&dtype), + vec![1i32.into(), 2i32.into()], + NonNullable, + ) + .as_list(), ) .unwrap(); @@ -555,12 +561,12 @@ mod tests { // Test u64 offsets with u16 sizes. let dtype2: Arc = Arc::new(I32.into()); let mut builder2 = - ListViewBuilder::::with_capacity(dtype2.clone(), NonNullable, 0, 0); + ListViewBuilder::::with_capacity(Arc::clone(&dtype2), NonNullable, 0, 0); for i in 0..5 { builder2 .append_value( - Scalar::list(dtype2.clone(), vec![(i * 10).into()], NonNullable).as_list(), + Scalar::list(Arc::clone(&dtype2), vec![(i * 10).into()], NonNullable).as_list(), ) .unwrap(); } @@ -580,7 +586,8 @@ mod tests { #[test] fn test_builder_trait_methods() { let dtype: Arc = Arc::new(I32.into()); - let mut builder = ListViewBuilder::::with_capacity(dtype.clone(), Nullable, 0, 0); + let mut builder = + ListViewBuilder::::with_capacity(Arc::clone(&dtype), Nullable, 0, 0); // Test append_zeros (creates empty lists). builder.append_zeros(2); @@ -638,7 +645,8 @@ mod tests { ) .unwrap(); - let mut builder = ListViewBuilder::::with_capacity(dtype.clone(), Nullable, 0, 0); + let mut builder = + ListViewBuilder::::with_capacity(Arc::clone(&dtype), Nullable, 0, 0); // Add initial data. builder @@ -692,7 +700,7 @@ mod tests { fn test_error_append_null_to_non_nullable() { let dtype: Arc = Arc::new(I32.into()); let mut builder = - ListViewBuilder::::with_capacity(dtype.clone(), NonNullable, 0, 0); + ListViewBuilder::::with_capacity(Arc::clone(&dtype), NonNullable, 0, 0); // Create a null list with nullable type (since Scalar::null requires nullable type). let null_scalar = Scalar::null(DType::List(dtype, Nullable)); @@ -715,7 +723,7 @@ mod tests { let dtype: Arc = Arc::new(I32.into()); let mut builder = - ListViewBuilder::::with_capacity(dtype.clone(), NonNullable, 20, 10); + ListViewBuilder::::with_capacity(Arc::clone(&dtype), NonNullable, 20, 10); // Append a primitive array as a single list entry. let arr1 = buffer![1i32, 2, 3].into_array(); @@ -724,8 +732,12 @@ mod tests { // Interleave with a list scalar. builder .append_value( - Scalar::list(dtype.clone(), vec![10i32.into(), 11i32.into()], NonNullable) - .as_list(), + Scalar::list( + Arc::clone(&dtype), + vec![10i32.into(), 11i32.into()], + NonNullable, + ) + .as_list(), ) .unwrap(); @@ -739,7 +751,7 @@ mod tests { // Interleave with another list scalar. builder - .append_value(Scalar::list_empty(dtype.clone(), NonNullable).as_list()) + .append_value(Scalar::list_empty(Arc::clone(&dtype), NonNullable).as_list()) .unwrap(); let listview = builder.finish_into_listview(); diff --git a/vortex-array/src/builders/mod.rs b/vortex-array/src/builders/mod.rs index f9914c8fb84..8093fcde4c3 100644 --- a/vortex-array/src/builders/mod.rs +++ b/vortex-array/src/builders/mod.rs @@ -29,6 +29,7 @@ //! ``` use std::any::Any; +use std::sync::Arc; use vortex_error::VortexResult; use vortex_error::vortex_panic; @@ -269,14 +270,19 @@ pub fn builder_with_capacity(dtype: &DType, capacity: usize) -> Box Box::new(ListViewBuilder::::with_capacity( - dtype.clone(), + Arc::clone(dtype), *n, 2 * capacity, // Arbitrarily choose 2 times the `offsets` capacity here. capacity, )), - DType::FixedSizeList(elem_dtype, list_size, null) => Box::new( - FixedSizeListBuilder::with_capacity(elem_dtype.clone(), *list_size, *null, capacity), - ), + DType::FixedSizeList(elem_dtype, list_size, null) => { + Box::new(FixedSizeListBuilder::with_capacity( + Arc::clone(elem_dtype), + *list_size, + *null, + capacity, + )) + } DType::Extension(ext_dtype) => { Box::new(ExtensionBuilder::with_capacity(ext_dtype.clone(), capacity)) } diff --git a/vortex-array/src/builders/tests.rs b/vortex-array/src/builders/tests.rs index 52b7db95bae..1a738954058 100644 --- a/vortex-array/src/builders/tests.rs +++ b/vortex-array/src/builders/tests.rs @@ -608,7 +608,7 @@ fn create_test_scalars_for_dtype(dtype: &DType, count: usize) -> Vec { _ => Scalar::default_value(element_dtype.as_ref()), }) .collect(); - Scalar::list(element_dtype.clone(), elements, *n) + Scalar::list(Arc::clone(element_dtype), elements, *n) } DType::FixedSizeList(element_dtype, size, n) => { // Create fixed-size list scalars. @@ -620,7 +620,7 @@ fn create_test_scalars_for_dtype(dtype: &DType, count: usize) -> Vec { _ => Scalar::default_value(element_dtype.as_ref()), }) .collect(); - Scalar::fixed_size_list(element_dtype.clone(), elements, *n) + Scalar::fixed_size_list(Arc::clone(element_dtype), elements, *n) } DType::Extension(ext_dtype) => { // Create extension scalars with storage values. diff --git a/vortex-array/src/canonical.rs b/vortex-array/src/canonical.rs index cdf569a075c..ffae20f09c8 100644 --- a/vortex-array/src/canonical.rs +++ b/vortex-array/src/canonical.rs @@ -1099,9 +1099,7 @@ mod test { .is_some() ); - let inner_struct = arrow_struct - .column(1) - .clone() + let inner_struct = Arc::clone(arrow_struct.column(1)) .as_any() .downcast_ref::() .cloned() diff --git a/vortex-array/src/compute/conformance/consistency.rs b/vortex-array/src/compute/conformance/consistency.rs index 2fa11d11949..dec1f8d1d61 100644 --- a/vortex-array/src/compute/conformance/consistency.rs +++ b/vortex-array/src/compute/conformance/consistency.rs @@ -19,6 +19,8 @@ //! interact with null values. //! - **Edge Cases**: Tests empty arrays, single elements, and boundary conditions. +use std::sync::Arc; + use vortex_buffer::BitBuffer; use vortex_error::VortexExpect; use vortex_error::vortex_panic; @@ -1227,7 +1229,7 @@ fn test_cast_slice_consistency(array: &ArrayRef) { Nullability::NonNullable => Nullability::Nullable, Nullability::Nullable => Nullability::NonNullable, }; - vec![DType::List(element_type.clone(), opposite)] + vec![DType::List(Arc::clone(element_type), opposite)] } DType::FixedSizeList(element_type, list_size, nullability) => { let opposite = match nullability { @@ -1235,7 +1237,7 @@ fn test_cast_slice_consistency(array: &ArrayRef) { Nullability::Nullable => Nullability::NonNullable, }; vec![DType::FixedSizeList( - element_type.clone(), + Arc::clone(element_type), *list_size, opposite, )] diff --git a/vortex-array/src/dtype/dtype_impl.rs b/vortex-array/src/dtype/dtype_impl.rs index fa655755b56..464dea36b09 100644 --- a/vortex-array/src/dtype/dtype_impl.rs +++ b/vortex-array/src/dtype/dtype_impl.rs @@ -88,8 +88,8 @@ impl DType { Utf8(_) => Utf8(nullability), Binary(_) => Binary(nullability), Struct(sf, _) => Struct(sf.clone(), nullability), - List(edt, _) => List(edt.clone(), nullability), - FixedSizeList(edt, size, _) => FixedSizeList(edt.clone(), *size, nullability), + List(edt, _) => List(Arc::clone(edt), nullability), + FixedSizeList(edt, size, _) => FixedSizeList(Arc::clone(edt), *size, nullability), Extension(ext) => Extension(ext.with_nullability(nullability)), Variant(_) => Variant(nullability), } @@ -539,7 +539,7 @@ mod tests { fn element_size_fixed_size_list() { let elem = Arc::new(DType::Primitive(PType::F64, NonNullable)); assert_eq!( - DType::FixedSizeList(elem.clone(), 1000, NonNullable).element_size(), + DType::FixedSizeList(Arc::clone(&elem), 1000, NonNullable).element_size(), Some(8000) ); diff --git a/vortex-array/src/scalar/tests/nested.rs b/vortex-array/src/scalar/tests/nested.rs index c4b28418c36..0aadd4ce2c9 100644 --- a/vortex-array/src/scalar/tests/nested.rs +++ b/vortex-array/src/scalar/tests/nested.rs @@ -19,14 +19,14 @@ mod tests { // Create FixedSizeList[2] of FixedSizeList[3] of I32. let inner_element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let inner_dtype = Arc::new(DType::FixedSizeList( - inner_element_dtype.clone(), + Arc::clone(&inner_element_dtype), 3, Nullability::NonNullable, )); // Create inner FixedSizeLists. let inner_list1 = Scalar::fixed_size_list( - inner_element_dtype.clone(), + Arc::clone(&inner_element_dtype), vec![ Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), @@ -87,12 +87,12 @@ mod tests { // Create FixedSizeList[2] of variable List of I32. let inner_element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let inner_dtype = Arc::new(DType::List( - inner_element_dtype.clone(), + Arc::clone(&inner_element_dtype), Nullability::NonNullable, )); let inner_list1 = Scalar::list( - inner_element_dtype.clone(), + Arc::clone(&inner_element_dtype), vec![ Scalar::primitive(10i32, Nullability::NonNullable), Scalar::primitive(20i32, Nullability::NonNullable), @@ -133,13 +133,13 @@ mod tests { // Create variable List of FixedSizeList[3] of I32. let inner_element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let inner_dtype = Arc::new(DType::FixedSizeList( - inner_element_dtype.clone(), + Arc::clone(&inner_element_dtype), 3, Nullability::NonNullable, )); let fixed_list1 = Scalar::fixed_size_list( - inner_element_dtype.clone(), + Arc::clone(&inner_element_dtype), vec![ Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), @@ -639,7 +639,7 @@ mod tests { )); let middle_fixed_list_dtype = Arc::new(DType::FixedSizeList( - struct_dtype.clone(), + Arc::clone(&struct_dtype), 2, Nullability::NonNullable, )); @@ -799,7 +799,7 @@ mod tests { )); let middle_dtype = Arc::new(DType::List( - innermost_dtype.clone(), + Arc::clone(&innermost_dtype), Nullability::NonNullable, )); @@ -824,7 +824,7 @@ mod tests { // Create middle Lists. let middle_list1 = Scalar::list( - innermost_dtype.clone(), + Arc::clone(&innermost_dtype), vec![inner_fixed1.clone()], Nullability::NonNullable, ); @@ -927,7 +927,7 @@ mod tests { // Test FixedSizeList[0] behavior. let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let empty_fixed_list = - Scalar::fixed_size_list(element_dtype.clone(), vec![], Nullability::NonNullable); + Scalar::fixed_size_list(Arc::clone(&element_dtype), vec![], Nullability::NonNullable); assert!(matches!( empty_fixed_list.dtype(), @@ -949,7 +949,7 @@ mod tests { fn test_fixed_size_list_cast_to_list() { let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let fixed_list = Scalar::fixed_size_list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![ Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), @@ -985,7 +985,7 @@ mod tests { fn test_list_cast_to_fixed_size_list() { let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let list = Scalar::list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![ Scalar::primitive(10i32, Nullability::NonNullable), Scalar::primitive(20i32, Nullability::NonNullable), @@ -1022,7 +1022,7 @@ mod tests { fn test_fixed_size_list_size_validation() { let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let list = Scalar::list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![ Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), @@ -1032,7 +1032,7 @@ mod tests { // Try to cast to wrong size - should fail. let wrong_size_target = - DType::FixedSizeList(element_dtype.clone(), 3, Nullability::NonNullable); + DType::FixedSizeList(Arc::clone(&element_dtype), 3, Nullability::NonNullable); let result = list.cast(&wrong_size_target); assert!(result.is_err()); assert!( @@ -1072,7 +1072,7 @@ mod tests { // Create two equal fixed size lists. let list1 = Scalar::fixed_size_list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![ Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), @@ -1081,7 +1081,7 @@ mod tests { ); let list2 = Scalar::fixed_size_list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![ Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), @@ -1113,7 +1113,7 @@ mod tests { // Test FixedSizeList[1]. let element_dtype = Arc::new(DType::Primitive(PType::I64, Nullability::NonNullable)); let single_element = Scalar::fixed_size_list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![Scalar::primitive(42i64, Nullability::NonNullable)], Nullability::NonNullable, ); @@ -1172,7 +1172,7 @@ mod tests { // FixedSizeList[3] of i32 = 3 * 4 bytes = 12 bytes. let fixed_list = Scalar::fixed_size_list( - element_dtype.clone(), + Arc::clone(&element_dtype), vec![ Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), diff --git a/vortex-array/src/scalar/tests/nullability.rs b/vortex-array/src/scalar/tests/nullability.rs index d70796d20ce..4d2bff418a5 100644 --- a/vortex-array/src/scalar/tests/nullability.rs +++ b/vortex-array/src/scalar/tests/nullability.rs @@ -589,7 +589,10 @@ mod tests { Nullability::Nullable, )); - let middle_dtype = Arc::new(DType::List(innermost_dtype.clone(), Nullability::Nullable)); + let middle_dtype = Arc::new(DType::List( + Arc::clone(&innermost_dtype), + Nullability::Nullable, + )); // Create innermost FixedSizeLists with different null patterns. let inner1 = Scalar::fixed_size_list( @@ -618,7 +621,7 @@ mod tests { // Create middle Lists. let middle1 = Scalar::list( - innermost_dtype.clone(), + Arc::clone(&innermost_dtype), vec![inner1, inner2], Nullability::Nullable, ); diff --git a/vortex-array/src/scalar/tests/round_trip.rs b/vortex-array/src/scalar/tests/round_trip.rs index c904a27f2ae..b3c09248687 100644 --- a/vortex-array/src/scalar/tests/round_trip.rs +++ b/vortex-array/src/scalar/tests/round_trip.rs @@ -220,7 +220,10 @@ mod tests { // Test nested lists let inner_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); - let outer_dtype = Arc::new(DType::List(inner_dtype.clone(), Nullability::NonNullable)); + let outer_dtype = Arc::new(DType::List( + Arc::clone(&inner_dtype), + Nullability::NonNullable, + )); let inner_list1 = Scalar::list( inner_dtype, diff --git a/vortex-array/src/scalar/typed_view/list.rs b/vortex-array/src/scalar/typed_view/list.rs index 6c4206f2a0e..3a158dd59ca 100644 --- a/vortex-array/src/scalar/typed_view/list.rs +++ b/vortex-array/src/scalar/typed_view/list.rs @@ -340,7 +340,11 @@ mod tests { Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), ]; - let list_scalar1 = Scalar::list(element_dtype.clone(), children1, Nullability::NonNullable); + let list_scalar1 = Scalar::list( + Arc::clone(&element_dtype), + children1, + Nullability::NonNullable, + ); let children2 = vec![ Scalar::primitive(1i32, Nullability::NonNullable), @@ -361,7 +365,11 @@ mod tests { Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), ]; - let list_scalar1 = Scalar::list(element_dtype.clone(), children1, Nullability::NonNullable); + let list_scalar1 = Scalar::list( + Arc::clone(&element_dtype), + children1, + Nullability::NonNullable, + ); let children2 = vec![ Scalar::primitive(1i32, Nullability::NonNullable), @@ -380,7 +388,11 @@ mod tests { let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let children1 = vec![Scalar::primitive(1i32, Nullability::NonNullable)]; - let list_scalar1 = Scalar::list(element_dtype.clone(), children1, Nullability::NonNullable); + let list_scalar1 = Scalar::list( + Arc::clone(&element_dtype), + children1, + Nullability::NonNullable, + ); let children2 = vec![Scalar::primitive(2i32, Nullability::NonNullable)]; let list_scalar2 = Scalar::list(element_dtype, children2, Nullability::NonNullable); @@ -521,12 +533,12 @@ mod tests { fn test_nested_lists() { let inner_element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)); let inner_list_dtype = Arc::new(DType::List( - inner_element_dtype.clone(), + Arc::clone(&inner_element_dtype), Nullability::NonNullable, )); let inner_list1 = Scalar::list( - inner_element_dtype.clone(), + Arc::clone(&inner_element_dtype), vec![ Scalar::primitive(1i32, Nullability::NonNullable), Scalar::primitive(2i32, Nullability::NonNullable), diff --git a/vortex-array/src/scalar_fn/fns/dynamic.rs b/vortex-array/src/scalar_fn/fns/dynamic.rs index 931d4aa96ba..de10fd64ad5 100644 --- a/vortex-array/src/scalar_fn/fns/dynamic.rs +++ b/vortex-array/src/scalar_fn/fns/dynamic.rs @@ -130,7 +130,7 @@ impl ScalarFnVTable for DynamicComparison { CompareOperator::Gt => Some(DynamicComparison.new_expr( DynamicComparisonExpr { operator: CompareOperator::Lte, - rhs: dynamic.rhs.clone(), + rhs: Arc::clone(&dynamic.rhs), default: !dynamic.default, }, vec![lhs.stat_max(catalog)?], @@ -138,7 +138,7 @@ impl ScalarFnVTable for DynamicComparison { CompareOperator::Gte => Some(DynamicComparison.new_expr( DynamicComparisonExpr { operator: CompareOperator::Lt, - rhs: dynamic.rhs.clone(), + rhs: Arc::clone(&dynamic.rhs), default: !dynamic.default, }, vec![lhs.stat_max(catalog)?], @@ -146,7 +146,7 @@ impl ScalarFnVTable for DynamicComparison { CompareOperator::Lt => Some(DynamicComparison.new_expr( DynamicComparisonExpr { operator: CompareOperator::Gte, - rhs: dynamic.rhs.clone(), + rhs: Arc::clone(&dynamic.rhs), default: !dynamic.default, }, vec![lhs.stat_min(catalog)?], @@ -154,7 +154,7 @@ impl ScalarFnVTable for DynamicComparison { CompareOperator::Lte => Some(DynamicComparison.new_expr( DynamicComparisonExpr { operator: CompareOperator::Gt, - rhs: dynamic.rhs.clone(), + rhs: Arc::clone(&dynamic.rhs), default: !dynamic.default, }, vec![lhs.stat_min(catalog)?], @@ -392,7 +392,7 @@ mod tests { #[test] fn execute_value_flips() -> VortexResult<()> { let threshold = Arc::new(AtomicI32::new(5)); - let threshold_clone = threshold.clone(); + let threshold_clone = Arc::clone(&threshold); let expr = dynamic( CompareOperator::Lt, move || Some(threshold_clone.load(Ordering::SeqCst).into()), diff --git a/vortex-array/src/scalar_fn/fns/merge.rs b/vortex-array/src/scalar_fn/fns/merge.rs index fa5e77bcdc3..1ad84462efd 100644 --- a/vortex-array/src/scalar_fn/fns/merge.rs +++ b/vortex-array/src/scalar_fn/fns/merge.rs @@ -215,10 +215,10 @@ impl ScalarFnVTable for Merge { for name in child_dtype.names().iter() { if let Some(idx) = names.iter().position(|n| n == name) { duplicate_names.insert(name.clone()); - children[idx] = child.clone(); + children[idx] = Arc::clone(&child); } else { names.push(name.clone()); - children.push(child.clone()); + children.push(Arc::clone(&child)); } } diff --git a/vortex-array/src/scalar_fn/fns/pack.rs b/vortex-array/src/scalar_fn/fns/pack.rs index cd276cfc561..1b04a47741b 100644 --- a/vortex-array/src/scalar_fn/fns/pack.rs +++ b/vortex-array/src/scalar_fn/fns/pack.rs @@ -4,6 +4,7 @@ use std::fmt::Display; use std::fmt::Formatter; use std::hash::Hash; +use std::sync::Arc; use itertools::Itertools as _; use prost::Message; @@ -90,7 +91,7 @@ impl ScalarFnVTable for Pack { fn child_name(&self, instance: &Self::Options, child_idx: usize) -> ChildName { match instance.names.get(child_idx) { - Some(name) => ChildName::from(name.inner().clone()), + Some(name) => ChildName::from(Arc::clone(name.inner())), None => unreachable!( "Invalid child index {} for Pack expression with {} fields", child_idx, diff --git a/vortex-bench/src/datasets/feature_vectors.rs b/vortex-bench/src/datasets/feature_vectors.rs index 7e0bc61bccc..e09f29f49ec 100644 --- a/vortex-bench/src/datasets/feature_vectors.rs +++ b/vortex-bench/src/datasets/feature_vectors.rs @@ -81,7 +81,7 @@ pub async fn feature_vectors_parquet() -> Result { ])); let file = File::create(&temp_path)?; - let mut writer = ArrowWriter::try_new(file, schema.clone(), None)?; + let mut writer = ArrowWriter::try_new(file, Arc::clone(&schema), None)?; let mut rng = StdRng::seed_from_u64(42); for batch_start in (0..ROW_COUNT).step_by(BATCH_SIZE) { @@ -100,8 +100,10 @@ pub async fn feature_vectors_parquet() -> Result { } let embedding = list_builder.finish(); - let batch = - RecordBatch::try_new(schema.clone(), vec![Arc::new(ids), Arc::new(embedding)])?; + let batch = RecordBatch::try_new( + Arc::clone(&schema), + vec![Arc::new(ids), Arc::new(embedding)], + )?; writer.write(&batch)?; } diff --git a/vortex-bench/src/datasets/nested_lists.rs b/vortex-bench/src/datasets/nested_lists.rs index b1461d66b42..3c89ed8eb2b 100644 --- a/vortex-bench/src/datasets/nested_lists.rs +++ b/vortex-bench/src/datasets/nested_lists.rs @@ -77,7 +77,7 @@ pub async fn nested_lists_parquet() -> Result { ])); let file = std::fs::File::create(&temp_path)?; - let mut writer = ArrowWriter::try_new(file, schema.clone(), None)?; + let mut writer = ArrowWriter::try_new(file, Arc::clone(&schema), None)?; let mut rng = StdRng::seed_from_u64(42); for batch_start in (0..ROW_COUNT).step_by(BATCH_SIZE) { @@ -97,8 +97,10 @@ pub async fn nested_lists_parquet() -> Result { } let values = list_builder.finish(); - let batch = - RecordBatch::try_new(schema.clone(), vec![Arc::new(ids), Arc::new(values)])?; + let batch = RecordBatch::try_new( + Arc::clone(&schema), + vec![Arc::new(ids), Arc::new(values)], + )?; writer.write(&batch)?; } diff --git a/vortex-bench/src/datasets/nested_structs.rs b/vortex-bench/src/datasets/nested_structs.rs index a7edff7e5dc..c4a522184d3 100644 --- a/vortex-bench/src/datasets/nested_structs.rs +++ b/vortex-bench/src/datasets/nested_structs.rs @@ -92,7 +92,7 @@ pub async fn nested_structs_parquet() -> Result { ])); let file = std::fs::File::create(&temp_path)?; - let mut writer = ArrowWriter::try_new(file, schema.clone(), None)?; + let mut writer = ArrowWriter::try_new(file, Arc::clone(&schema), None)?; let mut rng = StdRng::seed_from_u64(42); for batch_start in (0..ROW_COUNT).step_by(BATCH_SIZE) { @@ -124,8 +124,10 @@ pub async fn nested_structs_parquet() -> Result { None, )?; - let batch = - RecordBatch::try_new(schema.clone(), vec![Arc::new(ids), Arc::new(outer)])?; + let batch = RecordBatch::try_new( + Arc::clone(&schema), + vec![Arc::new(ids), Arc::new(outer)], + )?; writer.write(&batch)?; } diff --git a/vortex-bench/src/polarsignals/data.rs b/vortex-bench/src/polarsignals/data.rs index ed00f938cb9..eb2db956ee4 100644 --- a/vortex-bench/src/polarsignals/data.rs +++ b/vortex-bench/src/polarsignals/data.rs @@ -143,7 +143,7 @@ pub fn generate_polarsignals_parquet(n_rows: usize, output_path: &Path) -> Resul let props = WriterProperties::builder() .set_compression(Compression::SNAPPY) .build(); - let mut writer = ArrowWriter::try_new(file, schema.clone(), Some(props))?; + let mut writer = ArrowWriter::try_new(file, Arc::clone(&schema), Some(props))?; let batch_size = 10_000; let num_threads = std::thread::available_parallelism() @@ -159,11 +159,11 @@ pub fn generate_polarsignals_parquet(n_rows: usize, output_path: &Path) -> Resul chunk .iter() .map(|&(start, len)| { - let schema = schema.clone(); - let label_sets = label_sets.clone(); - let function_names = function_names.clone(); - let function_filenames = function_filenames.clone(); - let build_ids = build_ids.clone(); + let schema = Arc::clone(&schema); + let label_sets = Arc::clone(&label_sets); + let function_names = Arc::clone(&function_names); + let function_filenames = Arc::clone(&function_filenames); + let build_ids = Arc::clone(&build_ids); std::thread::spawn(move || { let mut rng = StdRng::seed_from_u64(42 + start as u64); build_batch( @@ -235,7 +235,7 @@ fn build_batch( } let batch = RecordBatch::try_new( - schema.clone(), + Arc::clone(schema), vec![ Arc::new(labels_array), Arc::new(locations_array), diff --git a/vortex-bench/src/random_access/take.rs b/vortex-bench/src/random_access/take.rs index 4ff1884f1e5..13358fb9531 100644 --- a/vortex-bench/src/random_access/take.rs +++ b/vortex-bench/src/random_access/take.rs @@ -3,6 +3,7 @@ use std::iter::once; use std::path::PathBuf; +use std::sync::Arc; use arrow_array::PrimitiveArray; use arrow_array::types::Int64Type; @@ -167,7 +168,7 @@ impl RandomAccessor for ParquetRandomAccessor { .with_batch_size(10_000_000) .build()?; - let schema = reader.schema().clone(); + let schema = Arc::clone(reader.schema()); let batches = reader .enumerate() diff --git a/vortex-bench/src/statpopgen/builder.rs b/vortex-bench/src/statpopgen/builder.rs index 25b6a2735b2..7c46d1ff2b8 100644 --- a/vortex-bench/src/statpopgen/builder.rs +++ b/vortex-bench/src/statpopgen/builder.rs @@ -437,7 +437,7 @@ impl<'a> GnomADBuilder<'a> { }); RecordBatch::try_new( - self.schema.clone(), + Arc::clone(&self.schema), variant_fields .into_iter() .chain(info_fields) diff --git a/vortex-bench/src/statpopgen/download_vcf.rs b/vortex-bench/src/statpopgen/download_vcf.rs index 503bf0b0e5f..ed1ab2826a6 100644 --- a/vortex-bench/src/statpopgen/download_vcf.rs +++ b/vortex-bench/src/statpopgen/download_vcf.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::Arc; + use anyhow::Context; use anyhow::Result; use anyhow::bail; @@ -74,14 +76,14 @@ impl StatPopGenBenchmark { ); let mut record = Record::default(); let schema = schema_from_vcf_header(&header); - let mut builder = GnomADBuilder::new(&header, schema.clone()); + let mut builder = GnomADBuilder::new(&header, Arc::clone(&schema)); let file = File::create(parquet_output_path).await?; - let mut writer = AsyncArrowWriter::try_new(file, schema.clone(), None) + let mut writer = AsyncArrowWriter::try_new(file, Arc::clone(&schema), None) .context("Failed to create parquet writer")?; for i in progress.wrap_iter(0..self.n_rows) { if i % ROW_GROUP_SIZE_IN_VARIANTS == 0 { let rb = builder.finish()?; - builder = GnomADBuilder::new(&header, schema.clone()); + builder = GnomADBuilder::new(&header, Arc::clone(&schema)); writer .write(&rb) .await diff --git a/vortex-bench/src/tpch/tpchgen.rs b/vortex-bench/src/tpch/tpchgen.rs index 75fe4db9e8f..1d7273f3ccc 100644 --- a/vortex-bench/src/tpch/tpchgen.rs +++ b/vortex-bench/src/tpch/tpchgen.rs @@ -136,7 +136,7 @@ pub async fn generate_tpch_tables(options: TpchGenOptions) -> Result<()> { let (tx, rx) = mpsc::unbounded_channel(); for f in all_futures { - let limiter = limiter.clone(); + let limiter = Arc::clone(&limiter); let tx = tx.clone(); tokio::task::spawn(async move { let _guard = limiter.acquire().await?; @@ -232,7 +232,7 @@ fn generate_table_files( let iter = create_single_batch_iterator(generator, &options_clone, partition_idx)?; // Create generator and process batches in streaming fashion - let schema = iter.schema().clone(); + let schema = Arc::clone(iter.schema()); // Create writer based on format let mut writer: Box = match write_format { diff --git a/vortex-cuda/src/device_buffer.rs b/vortex-cuda/src/device_buffer.rs index c8d2841f10a..3257318cde4 100644 --- a/vortex-cuda/src/device_buffer.rs +++ b/vortex-cuda/src/device_buffer.rs @@ -330,7 +330,7 @@ impl DeviceBuffer for CudaDeviceBuffer { let effective_ptr = self.device_ptr + self.offset as u64; if effective_ptr.is_multiple_of(*alignment as u64) { Ok(Arc::new(CudaDeviceBuffer { - allocation: self.allocation.clone(), + allocation: Arc::clone(&self.allocation), offset: self.offset, len: self.len, device_ptr: self.device_ptr, diff --git a/vortex-cuda/src/layout.rs b/vortex-cuda/src/layout.rs index 6ab2c08681b..7af7ba9e3de 100644 --- a/vortex-cuda/src/layout.rs +++ b/vortex-cuda/src/layout.rs @@ -246,7 +246,7 @@ impl CudaFlatReader { let session = self.session.clone(); let dtype = self.layout.dtype.clone(); let array_tree = self.layout.array_tree.clone(); - let host_buffers = self.layout.host_buffers.clone(); + let host_buffers = Arc::clone(&self.layout.host_buffers); async move { let segment = segment_fut.await?; @@ -308,7 +308,7 @@ impl LayoutReader for CudaFlatReader { .vortex_expect("Row range begin must fit within CudaFlatLayout size") ..usize::try_from(row_range.end) .vortex_expect("Row range end must fit within CudaFlatLayout size"); - let name = self.name.clone(); + let name = Arc::clone(&self.name); let array = self.array_future(); let expr = expr.clone(); let session = self.session.clone(); @@ -356,7 +356,7 @@ impl LayoutReader for CudaFlatReader { .vortex_expect("Row range begin must fit within CudaFlatLayout size") ..usize::try_from(row_range.end) .vortex_expect("Row range end must fit within CudaFlatLayout size"); - let name = self.name.clone(); + let name = Arc::clone(&self.name); let array = self.array_future(); let expr = expr.clone(); diff --git a/vortex-cuda/src/pinned.rs b/vortex-cuda/src/pinned.rs index c48cf98624b..7939bc588ec 100644 --- a/vortex-cuda/src/pinned.rs +++ b/vortex-cuda/src/pinned.rs @@ -143,7 +143,7 @@ impl PinnedByteBufferPool { /// Unlike `get`, this will never call `cuMemAllocHost`. pub fn try_get(self: &Arc, len: usize) -> VortexResult> { match self.try_get_inner(len)? { - Some(inner) => Ok(Some(PooledPinnedBuffer::new(inner, self.clone()))), + Some(inner) => Ok(Some(PooledPinnedBuffer::new(inner, Arc::clone(self)))), None => Ok(None), } } @@ -153,7 +153,7 @@ impl PinnedByteBufferPool { /// The buffer is returned to the pool when the [`PooledPinnedBuffer`] is dropped. pub(crate) fn get(self: &Arc, len: usize) -> VortexResult { let inner = self.get_inner(len)?; - Ok(PooledPinnedBuffer::new(inner, self.clone())) + Ok(PooledPinnedBuffer::new(inner, Arc::clone(self))) } /// Defer returning a pinned buffer to the pool until the CUDA event completes. diff --git a/vortex-cuda/src/stream.rs b/vortex-cuda/src/stream.rs index ce2c3fe9bd2..1b7c99c54a9 100644 --- a/vortex-cuda/src/stream.rs +++ b/vortex-cuda/src/stream.rs @@ -78,7 +78,7 @@ impl VortexCudaStream { .map_err(|e| vortex_err!("Failed to schedule H2D copy: {}", e))?; let cuda_buf = CudaDeviceBuffer::new(cuda_slice); - let stream = self.0.clone(); + let stream = Arc::clone(&self.0); Ok(Box::pin(async move { await_stream_callback(&stream).await?; diff --git a/vortex-datafusion/src/convert/exprs.rs b/vortex-datafusion/src/convert/exprs.rs index 79fec6e1e3e..654b82f2cab 100644 --- a/vortex-datafusion/src/convert/exprs.rs +++ b/vortex-datafusion/src/convert/exprs.rs @@ -952,7 +952,7 @@ mod tests { // WHEN value > 10 THEN 100 let when1 = Arc::new(df_expr::BinaryExpr::new( - col_value.clone(), + Arc::clone(&col_value), DFOperator::Gt, lit_10, )) as Arc; diff --git a/vortex-datafusion/src/lib.rs b/vortex-datafusion/src/lib.rs index 8e7fc57dbf5..75057365d11 100644 --- a/vortex-datafusion/src/lib.rs +++ b/vortex-datafusion/src/lib.rs @@ -106,7 +106,10 @@ mod common_tests { factory.get_ext().to_uppercase(), Arc::new(DefaultTableFactory::new()), ) - .with_object_store(&Url::try_from("file://").unwrap(), store.clone()); + .with_object_store( + &Url::try_from("file://").unwrap(), + Arc::::clone(&store), + ); if let Some(file_formats) = session_state_builder.file_formats() { file_formats.push(factory as _); @@ -124,7 +127,7 @@ mod common_tests { P: Into, { let array = ArrayRef::from_arrow(batch, false)?; - let mut write = ObjectStoreWrite::new(self.store.clone(), &path.into()).await?; + let mut write = ObjectStoreWrite::new(Arc::clone(&self.store), &path.into()).await?; VX_SESSION .write_options() .write(&mut write, array.to_array_stream()) diff --git a/vortex-datafusion/src/persistent/format.rs b/vortex-datafusion/src/persistent/format.rs index 0be2086c885..a1bb5895204 100644 --- a/vortex-datafusion/src/persistent/format.rs +++ b/vortex-datafusion/src/persistent/format.rs @@ -246,10 +246,10 @@ impl FileFormat for VortexFormat { let mut file_schemas = stream::iter(objects.iter().cloned()) .map(|object| { - let store = store.clone(); + let store = Arc::clone(store); let session = self.session.clone(); let opts = self.opts.clone(); - let cache = file_metadata_cache.clone(); + let cache = Arc::clone(&file_metadata_cache); SpawnedTask::spawn(async move { // Check if we have entry metadata for this file @@ -309,7 +309,7 @@ impl FileFormat for VortexFormat { object: &ObjectMeta, ) -> DFResult { let object = object.clone(); - let store = store.clone(); + let store = Arc::clone(store); let session = self.session.clone(); let opts = self.opts.clone(); let file_metadata_cache = state.runtime_env().cache_manager.get_file_metadata_cache(); @@ -516,7 +516,7 @@ impl FileFormat for VortexFormat { return not_impl_err!("Overwrites are not implemented yet for Vortex"); } - let schema = conf.output_schema().clone(); + let schema = Arc::clone(conf.output_schema()); let sink = Arc::new(VortexSink::new(conf, schema, self.session.clone())); Ok(Arc::new(DataSinkExec::new(input, sink, order_requirements)) as _) diff --git a/vortex-datafusion/src/persistent/mod.rs b/vortex-datafusion/src/persistent/mod.rs index c2d83532fe3..c8560cfb7a8 100644 --- a/vortex-datafusion/src/persistent/mod.rs +++ b/vortex-datafusion/src/persistent/mod.rs @@ -21,6 +21,8 @@ pub use source::VortexSource; #[cfg(test)] mod tests { + use std::sync::Arc; + use datafusion::arrow::util::pretty::pretty_format_batches; use datafusion_physical_plan::display::DisplayableExecutionPlan; use insta::assert_snapshot; @@ -65,7 +67,8 @@ mod tests { Validity::NonNullable, )?; - let mut writer = ObjectStoreWrite::new(ctx.store.clone(), &"test.vortex".into()).await?; + let mut writer = + ObjectStoreWrite::new(Arc::clone(&ctx.store), &"test.vortex".into()).await?; let summary = session .write_options() diff --git a/vortex-datafusion/src/persistent/opener.rs b/vortex-datafusion/src/persistent/opener.rs index b3d1bc548c4..ed216bab432 100644 --- a/vortex-datafusion/src/persistent/opener.rs +++ b/vortex-datafusion/src/persistent/opener.rs @@ -101,7 +101,7 @@ pub(crate) struct VortexOpener { impl FileOpener for VortexOpener { fn open(&self, file: PartitionedFile) -> DFResult { let session = self.session.clone(); - let metrics_registry = self.metrics_registry.clone(); + let metrics_registry = Arc::clone(&self.metrics_registry); let labels = vec![ Label::new(PATH_LABEL, file.path().to_string()), Label::new(PARTITION_LABEL, self.partition.to_string()), @@ -116,17 +116,17 @@ impl FileOpener for VortexOpener { InstrumentedReadAt::new_with_labels(reader, metrics_registry.as_ref(), labels.clone()); let file_pruning_predicate = self.file_pruning_predicate.clone(); - let expr_adapter_factory = self.expr_adapter_factory.clone(); + let expr_adapter_factory = Arc::clone(&self.expr_adapter_factory); let file_metadata_cache = self.file_metadata_cache.clone(); - let unified_file_schema = self.table_schema.file_schema().clone(); + let unified_file_schema = Arc::clone(self.table_schema.file_schema()); let batch_size = self.batch_size; let limit = self.limit; - let layout_reader = self.layout_readers.clone(); + let layout_reader = Arc::clone(&self.layout_readers); let has_output_ordering = self.has_output_ordering; let scan_concurrency = self.scan_concurrency; - let expr_convertor = self.expression_convertor.clone(); + let expr_convertor = Arc::clone(&self.expression_convertor); let projection_pushdown = self.projection_pushdown; // Replace column access for partition columns with literals @@ -163,7 +163,7 @@ impl FileOpener for VortexOpener { }) .and_then(|predicate| { FilePruner::try_new( - predicate.clone(), + Arc::clone(&predicate), &unified_file_schema, &file, Count::default(), @@ -181,7 +181,7 @@ impl FileOpener for VortexOpener { let mut open_opts = session .open_options() .with_file_size(file.object_meta.size) - .with_metrics_registry(metrics_registry.clone()) + .with_metrics_registry(Arc::clone(&metrics_registry)) .with_labels(labels); if let Some(file_metadata_cache) = file_metadata_cache @@ -591,14 +591,14 @@ mod tests { let file_path = "part=1/file.vortex"; let batch = record_batch!(("a", Int32, vec![Some(1), Some(2), Some(3)])).unwrap(); let data_size = - write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?; + write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?; let file_schema = batch.schema(); let mut file = PartitionedFile::new(file_path.to_string(), data_size); file.partition_values = vec![ScalarValue::Int32(Some(1))]; let table_schema = TableSchema::new( - file_schema.clone(), + Arc::clone(&file_schema), vec![Arc::new(Field::new("part", DataType::Int32, false))], ); @@ -606,7 +606,11 @@ mod tests { let filter = col("part").eq(lit(1)); let filter = logical2physical(&filter, table_schema.table_schema()); - let opener = make_opener(object_store.clone(), table_schema.clone(), Some(filter)); + let opener = make_opener( + Arc::clone(&object_store), + table_schema.clone(), + Some(filter), + ); let stream = opener.open(file.clone()).unwrap().await.unwrap(); let data = stream.try_collect::>().await?; @@ -619,7 +623,11 @@ mod tests { let filter = col("part").eq(lit(2)); let filter = logical2physical(&filter, table_schema.table_schema()); - let opener = make_opener(object_store.clone(), table_schema.clone(), Some(filter)); + let opener = make_opener( + Arc::clone(&object_store), + table_schema.clone(), + Some(filter), + ); let stream = opener.open(file.clone()).unwrap().await.unwrap(); let data = stream.try_collect::>().await?; @@ -638,7 +646,7 @@ mod tests { let data_batch = record_batch!(("a", Int32, Vec::::new())).unwrap(); let file_path = "part=1/empty.vortex"; let file_size = - write_arrow_to_vortex(object_store.clone(), file_path, data_batch.clone()).await?; + write_arrow_to_vortex(Arc::clone(&object_store), file_path, data_batch.clone()).await?; let file_schema = data_batch.schema(); // Parallel scans may attach a byte range even for empty files; the @@ -646,7 +654,7 @@ mod tests { let file = PartitionedFile::new_with_range(file_path.to_string(), file_size, 0, file_size as i64); - let table_schema = TableSchema::from_file_schema(file_schema.clone()); + let table_schema = TableSchema::from_file_schema(Arc::clone(&file_schema)); let opener = make_opener(object_store, table_schema, None); let stream = opener.open(file)?.await?; @@ -666,7 +674,7 @@ mod tests { let file1_path = "/path/file1.vortex"; let batch1 = record_batch!(("a", Int32, vec![Some(1), Some(2), Some(3)])).unwrap(); let data_size1 = - write_arrow_to_vortex(object_store.clone(), file1_path, batch1).await?; + write_arrow_to_vortex(Arc::clone(&object_store), file1_path, batch1).await?; PartitionedFile::new(file1_path.to_string(), data_size1) }; @@ -674,7 +682,7 @@ mod tests { let file2_path = "/path/file2.vortex"; let batch2 = record_batch!(("a", Int16, vec![Some(-1), Some(-2), Some(-3)])).unwrap(); let data_size2 = - write_arrow_to_vortex(object_store.clone(), file2_path, batch2).await?; + write_arrow_to_vortex(Arc::clone(&object_store), file2_path, batch2).await?; PartitionedFile::new(file2_path.to_string(), data_size2) }; @@ -688,7 +696,9 @@ mod tests { let make_opener = |filter| VortexOpener { partition: 1, session: SESSION.clone(), - vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store.clone())), + vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(Arc::clone( + &object_store, + ))), projection: ProjectionExprs::from_indices(&[0], table_schema.file_schema()), filter: Some(filter), file_pruning_predicate: None, @@ -708,7 +718,7 @@ mod tests { let filter = col("a").lt(lit(100_i32)); let filter = logical2physical(&filter, table_schema.table_schema()); - let opener1 = make_opener(filter.clone()); + let opener1 = make_opener(Arc::clone(&filter)); let stream = opener1.open(file1)?.await?; let format_opts = FormatOptions::new().with_types_info(true); @@ -725,7 +735,7 @@ mod tests { +-------+ "); - let opener2 = make_opener(filter.clone()); + let opener2 = make_opener(Arc::clone(&filter)); let stream = opener2.open(file2)?.await?; let data = stream.try_collect::>().await?; @@ -761,7 +771,7 @@ mod tests { ("a", Int32, vec![Some(100), Some(101), Some(102)]) ) .unwrap(); - let data_size = write_arrow_to_vortex(object_store.clone(), file_path, batch).await?; + let data_size = write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch).await?; let file = PartitionedFile::new(file_path.to_string(), data_size); // Table schema has columns in different order: a, b, c @@ -779,7 +789,7 @@ mod tests { filter: None, file_pruning_predicate: None, expr_adapter_factory: Arc::new(DefaultPhysicalExprAdapterFactory), - table_schema: TableSchema::from_file_schema(table_schema.clone()), + table_schema: TableSchema::from_file_schema(Arc::clone(&table_schema)), batch_size: 100, limit: None, metrics_registry: Arc::new(DefaultMetricsRegistry::default()), @@ -839,7 +849,7 @@ mod tests { )])), vec![Arc::new(struct_array)], )?; - let data_size = write_arrow_to_vortex(object_store.clone(), file_path, batch).await?; + let data_size = write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch).await?; // Table schema has an extra utf8 field. let table_schema = TableSchema::from_file_schema(Arc::new(Schema::new(vec![Field::new( @@ -861,7 +871,7 @@ mod tests { )]))); let opener = make_opener( - object_store.clone(), + Arc::clone(&object_store), table_schema.clone(), // expression references my_struct column which has different fields in each // field. @@ -900,7 +910,7 @@ mod tests { ("c", Int32, vec![Some(2)]) ) .unwrap(); - let data_size = write_arrow_to_vortex(object_store.clone(), file_path, batch).await?; + let data_size = write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch).await?; // Table schema has columns in DIFFERENT order: c, a, b // and different types that require casting (Utf8 -> Dictionary) @@ -925,7 +935,9 @@ mod tests { let opener = VortexOpener { partition: 1, session: SESSION.clone(), - vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store.clone())), + vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(Arc::clone( + &object_store, + ))), projection: ProjectionExprs::from_indices( projection.as_ref(), table_schema.file_schema(), @@ -1017,7 +1029,7 @@ mod tests { let batch = make_test_batch_with_10_rows(); let data_size = - write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?; + write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?; let schema = batch.schema(); let mut file = PartitionedFile::new(file_path.to_string(), data_size); @@ -1026,8 +1038,8 @@ mod tests { ))); let opener = make_test_opener( - object_store.clone(), - schema.clone(), + Arc::clone(&object_store), + Arc::clone(&schema), ProjectionExprs::from_indices(&[0, 1], &schema), ); @@ -1058,7 +1070,7 @@ mod tests { let batch = make_test_batch_with_10_rows(); let data_size = - write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?; + write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?; let schema = batch.schema(); let mut file = PartitionedFile::new(file_path.to_string(), data_size); @@ -1067,8 +1079,8 @@ mod tests { ))); let opener = make_test_opener( - object_store.clone(), - schema.clone(), + Arc::clone(&object_store), + Arc::clone(&schema), ProjectionExprs::from_indices(&[0, 1], &schema), ); @@ -1102,7 +1114,7 @@ mod tests { let batch = make_test_batch_with_10_rows(); let data_size = - write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?; + write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?; let schema = batch.schema(); let mut file = PartitionedFile::new(file_path.to_string(), data_size); @@ -1111,8 +1123,8 @@ mod tests { )); let opener = make_test_opener( - object_store.clone(), - schema.clone(), + Arc::clone(&object_store), + Arc::clone(&schema), ProjectionExprs::from_indices(&[0], &schema), ); @@ -1133,15 +1145,15 @@ mod tests { let batch = make_test_batch_with_10_rows(); let data_size = - write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?; + write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?; let schema = batch.schema(); let file = PartitionedFile::new(file_path.to_string(), data_size); // file.extensions is None by default let opener = make_test_opener( - object_store.clone(), - schema.clone(), + Arc::clone(&object_store), + Arc::clone(&schema), ProjectionExprs::from_indices(&[0], &schema), ); @@ -1165,10 +1177,10 @@ mod tests { ) .unwrap(); let data_size = - write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?; + write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?; let file_schema = batch.schema(); - let table_schema = TableSchema::from_file_schema(file_schema.clone()); + let table_schema = TableSchema::from_file_schema(Arc::clone(&file_schema)); // Create a projection that includes an arithmetic expression: a + b * 2 let col_a = df_expr::col("a", &file_schema)?; @@ -1188,7 +1200,9 @@ mod tests { let opener = VortexOpener { partition: 1, session: SESSION.clone(), - vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store.clone())), + vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(Arc::clone( + &object_store, + ))), projection, filter: None, file_pruning_predicate: None, @@ -1251,14 +1265,14 @@ mod tests { DataType::Struct(struct_fields.clone()), false, )])); - let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(struct_array)])?; + let batch = RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(struct_array)])?; let file_path = "/test.vortex"; - let data_size = write_arrow_to_vortex(object_store.clone(), file_path, batch).await?; + let data_size = write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch).await?; let opener = make_test_opener( - object_store.clone(), - schema.clone(), + Arc::clone(&object_store), + Arc::clone(&schema), ProjectionExprs::from_indices(&[0], &schema), ); let data: Vec<_> = opener diff --git a/vortex-datafusion/src/persistent/reader.rs b/vortex-datafusion/src/persistent/reader.rs index 4e480ca374f..fad6ef37eaf 100644 --- a/vortex-datafusion/src/persistent/reader.rs +++ b/vortex-datafusion/src/persistent/reader.rs @@ -46,7 +46,7 @@ impl VortexReaderFactory for DefaultVortexReaderFactory { session: &VortexSession, ) -> DFResult> { Ok(Arc::new(ObjectStoreReadAt::new( - self.object_store.clone(), + Arc::clone(&self.object_store), file.path().as_ref().into(), session.handle(), )) as _) diff --git a/vortex-datafusion/src/persistent/sink.rs b/vortex-datafusion/src/persistent/sink.rs index 60cf1a8d0f4..263579a8cd5 100644 --- a/vortex-datafusion/src/persistent/sink.rs +++ b/vortex-datafusion/src/persistent/sink.rs @@ -113,7 +113,7 @@ impl FileSink for VortexSink { // 1. We can probably be better at signaling how much memory we're consuming (potentially when reading too), see ParquetSink::spawn_writer_tasks_and_join. while let Some((path, rx)) = file_stream_rx.recv().await { let session = self.session.clone(); - let object_store = object_store.clone(); + let object_store = Arc::clone(&object_store); let writer_schema = get_writer_schema(&self.config); let dtype = DType::from_arrow(writer_schema); @@ -267,7 +267,7 @@ mod tests { let logical_plan = LogicalPlanBuilder::insert_into( LogicalPlan::Values(values.clone()), "my_tbl", - Arc::new(DefaultTableSource::new(tbl_provider.clone())), + Arc::new(DefaultTableSource::new(Arc::clone(&tbl_provider))), datafusion::logical_expr::dml::InsertOp::Append, )? .build()?; diff --git a/vortex-datafusion/src/persistent/source.rs b/vortex-datafusion/src/persistent/source.rs index bac7fe2b39a..537e6162d0b 100644 --- a/vortex-datafusion/src/persistent/source.rs +++ b/vortex-datafusion/src/persistent/source.rs @@ -186,8 +186,8 @@ impl FileSource for VortexSource { table_schema: self.table_schema.clone(), batch_size, limit: base_config.limit.map(|l| l as u64), - metrics_registry: self.vx_metrics_registry.clone(), - layout_readers: self.layout_readers.clone(), + metrics_registry: Arc::clone(&self.vx_metrics_registry), + layout_readers: Arc::clone(&self.layout_readers), has_output_ordering: !base_config.output_ordering.is_empty(), expression_convertor: Arc::new(DefaultExpressionConvertor::default()), file_metadata_cache: self.file_metadata_cache.clone(), diff --git a/vortex-datafusion/src/tests/schema_evolution.rs b/vortex-datafusion/src/tests/schema_evolution.rs index 02254ef6afd..093fed6c148 100644 --- a/vortex-datafusion/src/tests/schema_evolution.rs +++ b/vortex-datafusion/src/tests/schema_evolution.rs @@ -236,7 +236,7 @@ async fn test_filter_schema_evolution_struct_fields( let read_schema = host02.schema(); let provider = ctx - .table_provider("tbl", "/files/", read_schema.clone()) + .table_provider("tbl", "/files/", Arc::clone(&read_schema)) .await?; let table = ctx.session.read_table(provider)?; @@ -359,7 +359,7 @@ async fn test_schema_evolution_struct_of_dict( let read_schema = batch.schema(); let provider = ctx - .table_provider("tbl", "/files/", read_schema.clone()) + .table_provider("tbl", "/files/", Arc::clone(&read_schema)) .await?; let table = ctx.session.read_table(provider)?; @@ -582,7 +582,7 @@ async fn test_dictionary_column_type_preservation( // Create table with explicit schema that expects Dictionary types let table_schema = batch.schema(); let provider = ctx - .table_provider("tbl", "/files/", table_schema.clone()) + .table_provider("tbl", "/files/", Arc::clone(&table_schema)) .await?; let table = ctx.session.read_table(provider)?; @@ -652,13 +652,15 @@ async fn test_nested_struct_dictionary_type_preservation( ])); let batch = RecordBatch::try_new( - schema.clone(), + Arc::clone(&schema), vec![Arc::new(labels_struct), value_array, producer_array], )?; ctx.write_arrow_batch("files/data.vortex", &batch).await?; - let provider = ctx.table_provider("tbl", "/files/", schema.clone()).await?; + let provider = ctx + .table_provider("tbl", "/files/", Arc::clone(&schema)) + .await?; let table = ctx.session.read_table(provider)?; // Query that projects a nested struct field (like in polarsignals Q0) @@ -740,7 +742,7 @@ async fn test_polarsignals_like_schema( ])); let batch = RecordBatch::try_new( - schema.clone(), + Arc::clone(&schema), vec![ Arc::new(labels_struct), value_array, @@ -754,7 +756,9 @@ async fn test_polarsignals_like_schema( ctx.write_arrow_batch("files/data.vortex", &batch).await?; - let provider = ctx.table_provider("tbl", "/files/", schema.clone()).await?; + let provider = ctx + .table_provider("tbl", "/files/", Arc::clone(&schema)) + .await?; let table = ctx.session.read_table(provider)?; // Query like polarsignals Q0: filter on multiple dictionary columns, project value and labels.comm @@ -815,7 +819,7 @@ async fn test_external_table_dictionary_columns( ])); let batch = RecordBatch::try_new( - schema.clone(), + Arc::clone(&schema), vec![producer_array, sample_type_array, value_array], )?; @@ -901,7 +905,7 @@ async fn test_sql_struct_field_dictionary_type( ])); let batch = RecordBatch::try_new( - schema.clone(), + Arc::clone(&schema), vec![ Arc::new(labels_struct), value_array, diff --git a/vortex-datafusion/src/v2/source.rs b/vortex-datafusion/src/v2/source.rs index 3f3adb478d4..b2530c445bb 100644 --- a/vortex-datafusion/src/v2/source.rs +++ b/vortex-datafusion/src/v2/source.rs @@ -162,11 +162,11 @@ impl VortexDataSourceBuilder { Ok(VortexDataSource { data_source: self.data_source, session: self.session, - initial_schema: arrow_schema.clone(), + initial_schema: Arc::clone(&arrow_schema), initial_projection: projection.clone(), initial_statistics: statistics.clone(), projected_projection: projection.clone(), - projected_schema: arrow_schema.clone(), + projected_schema: Arc::clone(&arrow_schema), projected_statistics: statistics.clone(), leftover_projection: None, leftover_schema: arrow_schema, @@ -285,8 +285,8 @@ impl DataSource for VortexDataSource { ..Default::default() }; - let data_source = self.data_source.clone(); - let projected_schema = self.projected_schema.clone(); + let data_source = Arc::clone(&self.data_source); + let projected_schema = Arc::clone(&self.projected_schema); let session = self.session.clone(); let num_partitions = self.num_partitions; @@ -318,7 +318,7 @@ impl DataSource for VortexDataSource { .try_flatten_unordered(Some(num_partitions.get() * 2)) .map(move |result| { let session = session.clone(); - let schema = projected_schema.clone(); + let schema = Arc::clone(&projected_schema); handle.spawn_cpu(move || { let mut ctx = session.create_execution_ctx(); result.and_then(|chunk| chunk.execute_record_batch(&schema, &mut ctx)) @@ -343,7 +343,7 @@ impl DataSource for VortexDataSource { .try_flatten(); Ok(Box::pin(RecordBatchStreamAdapter::new( - self.leftover_schema.clone(), + Arc::clone(&self.leftover_schema), stream, ))) } @@ -386,7 +386,7 @@ impl DataSource for VortexDataSource { } fn eq_properties(&self) -> EquivalenceProperties { - EquivalenceProperties::new(self.leftover_schema.clone()) + EquivalenceProperties::new(Arc::clone(&self.leftover_schema)) } fn partition_statistics(&self, _partition: Option) -> DFResult { @@ -467,11 +467,11 @@ impl DataSource for VortexDataSource { let mut this = self.clone(); this.projected_projection = scan_projection; - this.projected_schema = scan_output_schema.clone(); + this.projected_schema = Arc::clone(&scan_output_schema); this.projected_statistics = vec![ColumnStatistics::new_unknown(); scan_output_schema.fields().len()]; this.leftover_projection = Some(leftover_projection); - this.leftover_schema = final_schema.clone(); + this.leftover_schema = Arc::clone(&final_schema); this.leftover_statistics = vec![ColumnStatistics::new_unknown(); final_schema.fields().len()]; @@ -517,7 +517,7 @@ impl DataSource for VortexDataSource { .iter() .zip(pushdown_results.iter()) .filter_map(|(expr, pushed)| match pushed { - PushedDown::Yes => Some(expr.clone()), + PushedDown::Yes => Some(Arc::clone(expr)), PushedDown::No => None, }) .collect(); diff --git a/vortex-datafusion/src/v2/table.rs b/vortex-datafusion/src/v2/table.rs index 410162b639a..05edc0f27d8 100644 --- a/vortex-datafusion/src/v2/table.rs +++ b/vortex-datafusion/src/v2/table.rs @@ -66,7 +66,7 @@ impl TableProvider for VortexTable { } fn schema(&self) -> SchemaRef { - self.arrow_schema.clone() + Arc::clone(&self.arrow_schema) } fn table_type(&self) -> TableType { @@ -81,22 +81,23 @@ impl TableProvider for VortexTable { _limit: Option, ) -> DFResult> { // Construct the physical node representing this table. - let data_source = VortexDataSource::builder(self.data_source.clone(), self.session.clone()) - .with_arrow_schema(self.arrow_schema.clone()) - // We push down the projection now since it can make building the physical plan a lot - // cheaper, e.g. by only computing stats for the projected columns. - .with_some_projection(projection.cloned()) - // We don't push down filters for two reasons: - // 1. Vortex requires a physical expression, not logical. DataFusion will try to push - // the physical filters later. - // 2. There's nothing useful we can do with filters now to reduce the amount of work - // we have to do. - // - // We also don't push down the limit for the same reason, there's nothing useful we - // can do with it. - .build() - .await - .map_err(|e| DataFusionError::External(Box::new(e)))?; + let data_source = + VortexDataSource::builder(Arc::clone(&self.data_source), self.session.clone()) + .with_arrow_schema(Arc::clone(&self.arrow_schema)) + // We push down the projection now since it can make building the physical plan a lot + // cheaper, e.g. by only computing stats for the projected columns. + .with_some_projection(projection.cloned()) + // We don't push down filters for two reasons: + // 1. Vortex requires a physical expression, not logical. DataFusion will try to push + // the physical filters later. + // 2. There's nothing useful we can do with filters now to reduce the amount of work + // we have to do. + // + // We also don't push down the limit for the same reason, there's nothing useful we + // can do with it. + .build() + .await + .map_err(|e| DataFusionError::External(Box::new(e)))?; Ok(DataSourceExec::from_data_source(data_source)) } diff --git a/vortex-duckdb/src/datasource.rs b/vortex-duckdb/src/datasource.rs index 64f9f0c5474..fe6336d3856 100644 --- a/vortex-duckdb/src/datasource.rs +++ b/vortex-duckdb/src/datasource.rs @@ -111,7 +111,7 @@ pub struct DataSourceBindData { impl Clone for DataSourceBindData { fn clone(&self) -> Self { Self { - data_source: self.data_source.clone(), + data_source: Arc::clone(&self.data_source), // filter_exprs are consumed once in `init_global`. filter_exprs: vec![], column_names: self.column_names.clone(), @@ -265,7 +265,11 @@ impl TableFunction for T { } }; while let Some(item) = stream.next().await { - if tx.send(item.map(|a| (a, cache.clone()))).await.is_err() { + if tx + .send(item.map(|a| (a, Arc::clone(&cache)))) + .await + .is_err() + { // Exit early if the receiver has been dropped, which happens when the // scan is complete or if an error has occurred in another partition. return; diff --git a/vortex-duckdb/src/duckdb/file_system.rs b/vortex-duckdb/src/duckdb/file_system.rs index a052ecb8ff7..a3c76af633d 100644 --- a/vortex-duckdb/src/duckdb/file_system.rs +++ b/vortex-duckdb/src/duckdb/file_system.rs @@ -114,7 +114,7 @@ impl VortexWrite for DuckDbFsWriter { async fn write_all(&mut self, buffer: B) -> std::io::Result { let len = buffer.bytes_init(); let offset = self.pos; - let handle = self.handle.clone(); + let handle = Arc::clone(&self.handle); let runtime = RUNTIME.handle(); let buffer = runtime @@ -145,7 +145,7 @@ impl VortexWrite for DuckDbFsWriter { } async fn flush(&mut self) -> std::io::Result<()> { - let handle = self.handle.clone(); + let handle = Arc::clone(&self.handle); let runtime = RUNTIME.handle(); runtime diff --git a/vortex-duckdb/src/exporter/list.rs b/vortex-duckdb/src/exporter/list.rs index 7c807a7d6ef..1ae14869908 100644 --- a/vortex-duckdb/src/exporter/list.rs +++ b/vortex-duckdb/src/exporter/list.rs @@ -64,7 +64,7 @@ pub(crate) fn new_exporter( let cached_elements = cache .values_cache .get(&values_key) - .map(|entry| entry.value().1.clone()); + .map(|entry| Arc::clone(&entry.value().1)); let shared_elements = match cached_elements { Some(elements) => elements, @@ -82,7 +82,7 @@ pub(crate) fn new_exporter( let shared_elements = Arc::new(Mutex::new(duckdb_elements)); cache .values_cache - .insert(values_key, (elements, shared_elements.clone())); + .insert(values_key, (elements, Arc::clone(&shared_elements))); shared_elements } diff --git a/vortex-duckdb/src/exporter/list_view.rs b/vortex-duckdb/src/exporter/list_view.rs index 5bdd9fe5ab7..dcc7c66ce31 100644 --- a/vortex-duckdb/src/exporter/list_view.rs +++ b/vortex-duckdb/src/exporter/list_view.rs @@ -69,7 +69,7 @@ pub(crate) fn new_exporter( let cached_elements = cache .values_cache .get(&values_key) - .map(|entry| entry.value().1.clone()); + .map(|entry| Arc::clone(&entry.value().1)); let shared_elements = match cached_elements { Some(elements) => elements, @@ -87,7 +87,7 @@ pub(crate) fn new_exporter( let shared_elements = Arc::new(Mutex::new(duckdb_elements)); cache .values_cache - .insert(values_key, (elements, shared_elements.clone())); + .insert(values_key, (elements, Arc::clone(&shared_elements))); shared_elements } diff --git a/vortex-duckdb/src/filesystem.rs b/vortex-duckdb/src/filesystem.rs index 5e11c341114..e6d5c7c9750 100644 --- a/vortex-duckdb/src/filesystem.rs +++ b/vortex-duckdb/src/filesystem.rs @@ -261,8 +261,8 @@ impl VortexReadAt for DuckDbFsReader { } fn size(&self) -> BoxFuture<'static, VortexResult> { - let handle = self.handle.clone(); - let size_cell = self.size.clone(); + let handle = Arc::clone(&self.handle); + let size_cell = Arc::clone(&self.size); async move { if let Some(size) = size_cell.get() { @@ -296,7 +296,7 @@ impl VortexReadAt for DuckDbFsReader { length: usize, alignment: Alignment, ) -> BoxFuture<'static, VortexResult> { - let handle = self.handle.clone(); + let handle = Arc::clone(&self.handle); async move { let runtime = RUNTIME.handle(); diff --git a/vortex-ffi/src/dtype.rs b/vortex-ffi/src/dtype.rs index 376c70b5e8a..f404187bb9f 100644 --- a/vortex-ffi/src/dtype.rs +++ b/vortex-ffi/src/dtype.rs @@ -318,7 +318,7 @@ pub unsafe extern "C-unwind" fn vx_dtype_time_zone(dtype: *const DType) -> *cons }; match opts.tz.as_ref() { - Some(zone) => vx_string::new(zone.clone()), + Some(zone) => vx_string::new(Arc::clone(zone)), None => ptr::null(), } } diff --git a/vortex-file/src/counting.rs b/vortex-file/src/counting.rs index 6eaa8f07d16..78f8a8741a9 100644 --- a/vortex-file/src/counting.rs +++ b/vortex-file/src/counting.rs @@ -24,7 +24,7 @@ impl CountingVortexWrite { } pub fn counter(&self) -> Arc { - self.bytes_written.clone() + Arc::clone(&self.bytes_written) } } diff --git a/vortex-file/src/file.rs b/vortex-file/src/file.rs index b4a1865b014..7257676b05c 100644 --- a/vortex-file/src/file.rs +++ b/vortex-file/src/file.rs @@ -78,7 +78,7 @@ impl VortexFile { /// This may spawn a background I/O driver that will exit when the returned segment source /// is dropped. pub fn segment_source(&self) -> Arc { - self.segment_source.clone() + Arc::clone(&self.segment_source) } /// Create a new layout reader for the file. diff --git a/vortex-file/src/footer/serializer.rs b/vortex-file/src/footer/serializer.rs index 493d10871a8..af5a7f9e909 100644 --- a/vortex-file/src/footer/serializer.rs +++ b/vortex-file/src/footer/serializer.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::Arc; + use vortex_buffer::ByteBuffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; @@ -97,7 +99,7 @@ impl FooterSerializer { &FooterFlatBufferWriter { ctx: self.footer.array_read_ctx.clone(), layout_ctx: ReadContext::new(layout_ctx.to_ids()), - segment_specs: self.footer.segments.clone(), + segment_specs: Arc::clone(&self.footer.segments), }, )?; buffers.push(buffer); diff --git a/vortex-file/src/multi/mod.rs b/vortex-file/src/multi/mod.rs index d701bda5e27..2e0c3735499 100644 --- a/vortex-file/src/multi/mod.rs +++ b/vortex-file/src/multi/mod.rs @@ -127,10 +127,10 @@ impl MultiFileDataSource { .iter() .map(|f| { Arc::new(VortexFileReaderFactory { - fs: fs.clone(), + fs: Arc::clone(&fs), file: f.clone(), session: self.session.clone(), - open_options_fn: self.open_options_fn.clone(), + open_options_fn: Arc::clone(&self.open_options_fn), }) as Arc }) .collect(); diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs index 049010f0d71..2231796b2e8 100644 --- a/vortex-file/src/open.rs +++ b/vortex-file/src/open.rs @@ -184,7 +184,7 @@ impl VortexOpenOptions { let segment_source = Arc::new(BufferSegmentSource::new( buffer, - footer.segment_map().clone(), + Arc::clone(footer.segment_map()), )); Ok(VortexFile { @@ -225,7 +225,7 @@ impl VortexOpenOptions { // Create a segment source backed by the VortexRead implementation. let segment_source = Arc::new(SharedSegmentSource::new(FileSegmentSource::open( - footer.segment_map().clone(), + Arc::clone(footer.segment_map()), reader, self.session.handle(), metrics, @@ -330,7 +330,7 @@ impl VortexOpenOptions { let handle = self.session.handle(); let source = Arc::new(ObjectStoreReadAt::new( - object_store.clone(), + Arc::clone(object_store), path.into(), handle, )); @@ -430,8 +430,8 @@ mod tests { let first_read_len = Arc::new(AtomicUsize::new(0)); let reader = CountingRead { inner: buffer, - total_read: total_read.clone(), - first_read_len: first_read_len.clone(), + total_read: Arc::clone(&total_read), + first_read_len: Arc::clone(&first_read_len), }; // Open the file diff --git a/vortex-file/src/read/request.rs b/vortex-file/src/read/request.rs index cdd71670070..7caaa08d3d8 100644 --- a/vortex-file/src/read/request.rs +++ b/vortex-file/src/read/request.rs @@ -140,7 +140,7 @@ impl CoalescedRequest { Err(e) => { let e = Arc::new(e); for req in self.requests.into_iter() { - req.resolve(Err(VortexError::from(e.clone()))); + req.resolve(Err(VortexError::from(Arc::clone(&e)))); } return; } @@ -163,7 +163,7 @@ impl CoalescedRequest { Err(e) => { let e = Arc::new(e); for req in self.requests.into_iter() { - req.resolve(Err(VortexError::from(e.clone()))); + req.resolve(Err(VortexError::from(Arc::clone(&e)))); } } } diff --git a/vortex-file/src/strategy.rs b/vortex-file/src/strategy.rs index 665e34684bd..826b7773a78 100644 --- a/vortex-file/src/strategy.rs +++ b/vortex-file/src/strategy.rs @@ -219,7 +219,7 @@ impl WriteStrategyBuilder { }; // 7. for each chunk create a flat layout - let chunked = ChunkedLayoutStrategy::new(flat.clone()); + let chunked = ChunkedLayoutStrategy::new(Arc::clone(&flat)); // 6. buffer chunks so they end up with closer segment ids physically let buffered = BufferedStrategy::new(chunked, 2 * ONE_MEG); // 2MB @@ -234,7 +234,7 @@ impl WriteStrategyBuilder { .exclude_schemes([IntDictScheme.id()]) .build(), ), - CompressorConfig::Opaque(compressor) => compressor.clone(), + CompressorConfig::Opaque(compressor) => Arc::clone(compressor), }; let compressing = CompressingStrategy::new(buffered, data_compressor); diff --git a/vortex-file/src/v2/file_stats_reader.rs b/vortex-file/src/v2/file_stats_reader.rs index ab3fe42ffca..bee460066b2 100644 --- a/vortex-file/src/v2/file_stats_reader.rs +++ b/vortex-file/src/v2/file_stats_reader.rs @@ -266,7 +266,7 @@ mod tests { let layout = strategy .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), struct_array.into_array().to_array_stream().sequenced(ptr), eof, handle, @@ -304,7 +304,7 @@ mod tests { let layout = strategy .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), struct_array.into_array().to_array_stream().sequenced(ptr), eof, handle, diff --git a/vortex-file/src/writer.rs b/vortex-file/src/writer.rs index ef91dc701c0..66b6226c6fa 100644 --- a/vortex-file/src/writer.rs +++ b/vortex-file/src/writer.rs @@ -182,7 +182,13 @@ impl VortexWriteOptions { let layout_fut = self.session.handle().spawn_nested(|h| async move { let layout = self .strategy - .write_stream(ctx2, segments.clone(), stream, eof, h) + .write_stream( + ctx2, + Arc::::clone(&segments), + stream, + eof, + h, + ) .await?; Ok::<_, VortexError>((layout, segments.segment_specs())) }); @@ -202,7 +208,7 @@ impl VortexWriteOptions { // Assemble the Footer object now that we have all the segments. let mut footer = Footer::new( - layout.clone(), + Arc::clone(&layout), segment_specs, if self.file_statistics.is_empty() { None @@ -250,7 +256,7 @@ impl VortexWriteOptions { let write = CountingVortexWrite::new(write); let bytes_written = write.counter(); - let strategy = self.strategy.clone(); + let strategy = Arc::clone(&self.strategy); let future = self.write(write, arrays).boxed_local().fuse(); Writer { diff --git a/vortex-io/src/limit.rs b/vortex-io/src/limit.rs index 52c7c4b285d..f49ea7a3661 100644 --- a/vortex-io/src/limit.rs +++ b/vortex-io/src/limit.rs @@ -81,9 +81,7 @@ where // Attempt to acquire enough permits to begin working on a request that will occupy // `bytes` amount of memory when it completes. // Acquiring the permits is what creates backpressure for the producer. - let permits = self - .bytes_available - .clone() + let permits = Arc::clone(&self.bytes_available) .acquire_many_owned(bytes.try_into().vortex_expect("bytes must fit in u32")) .await .unwrap_or_else(|_| unreachable!("pushing to closed semaphore")); @@ -102,9 +100,7 @@ where /// /// If there is not enough capacity, the original future is returned to the caller. pub fn try_push(&self, fut: Fut, bytes: usize) -> Result<(), Fut> { - match self - .bytes_available - .clone() + match Arc::clone(&self.bytes_available) .try_acquire_many_owned(bytes.try_into().vortex_expect("bytes must fit in u32")) { Ok(permits) => { diff --git a/vortex-io/src/object_store/filesystem.rs b/vortex-io/src/object_store/filesystem.rs index 4a328725a40..6fdbc23caa3 100644 --- a/vortex-io/src/object_store/filesystem.rs +++ b/vortex-io/src/object_store/filesystem.rs @@ -76,7 +76,7 @@ impl FileSystem for ObjectStoreFileSystem { async fn open_read(&self, path: &str) -> VortexResult> { Ok(Arc::new(ObjectStoreReadAt::new( - self.store.clone(), + Arc::clone(&self.store), path.into(), self.handle.clone(), ))) diff --git a/vortex-io/src/object_store/read_at.rs b/vortex-io/src/object_store/read_at.rs index a4957199565..727b792571b 100644 --- a/vortex-io/src/object_store/read_at.rs +++ b/vortex-io/src/object_store/read_at.rs @@ -80,7 +80,7 @@ impl VortexReadAt for ObjectStoreReadAt { } fn size(&self) -> BoxFuture<'static, VortexResult> { - let store = self.store.clone(); + let store = Arc::clone(&self.store); let path = self.path.clone(); async move { store @@ -98,7 +98,7 @@ impl VortexReadAt for ObjectStoreReadAt { length: usize, alignment: Alignment, ) -> BoxFuture<'static, VortexResult> { - let store = self.store.clone(); + let store = Arc::clone(&self.store); let path = self.path.clone(); let handle = self.handle.clone(); let range = offset..(offset + length as u64); diff --git a/vortex-io/src/object_store/write.rs b/vortex-io/src/object_store/write.rs index 988fd1473ac..3cb73cec331 100644 --- a/vortex-io/src/object_store/write.rs +++ b/vortex-io/src/object_store/write.rs @@ -129,7 +129,7 @@ mod tests { let location = Path::from("test.bin"); for test_store in [memory_store, local_store] { - let mut writer = ObjectStoreWrite::new(test_store.clone(), &location).await?; + let mut writer = ObjectStoreWrite::new(Arc::clone(&test_store), &location).await?; #[expect(clippy::cast_possible_truncation)] let data = (0..3) diff --git a/vortex-io/src/runtime/current.rs b/vortex-io/src/runtime/current.rs index 1d2eda71487..c49d9e010a5 100644 --- a/vortex-io/src/runtime/current.rs +++ b/vortex-io/src/runtime/current.rs @@ -45,7 +45,7 @@ impl CurrentThreadRuntime { /// By default, the pool has no worker threads; the caller must set the desired number of /// worker threads using the `set_workers` method on the returned pool. pub fn new_pool(&self) -> CurrentThreadWorkerPool { - CurrentThreadWorkerPool::new(self.executor.clone()) + CurrentThreadWorkerPool::new(Arc::clone(&self.executor)) } /// Returns an iterator wrapper around a stream, blocking the current thread for each item. @@ -81,7 +81,7 @@ impl CurrentThreadRuntime { .detach(); ThreadSafeIterator { - executor: self.executor.clone(), + executor: Arc::clone(&self.executor), results: result_rx, } } @@ -91,7 +91,7 @@ impl BlockingRuntime for CurrentThreadRuntime { type BlockingIterator<'a, R: 'a> = CurrentThreadIterator<'a, R>; fn handle(&self) -> Handle { - let executor: Arc = self.executor.clone(); + let executor: Arc = Arc::clone(&self.executor) as Arc; Handle::new(Arc::downgrade(&executor)) } @@ -108,7 +108,7 @@ impl BlockingRuntime for CurrentThreadRuntime { R: Send + 'a, { CurrentThreadIterator { - executor: self.executor.clone(), + executor: Arc::clone(&self.executor), stream: stream.boxed(), } } @@ -138,7 +138,7 @@ pub struct ThreadSafeIterator { impl Clone for ThreadSafeIterator { fn clone(&self) -> Self { Self { - executor: self.executor.clone(), + executor: Arc::clone(&self.executor), results: self.results.clone(), } } @@ -174,7 +174,7 @@ mod tests { // We spawn a future that sets a value on a separate thread. let value = Arc::new(AtomicUsize::new(0)); - let value2 = value.clone(); + let value2 = Arc::clone(&value); runtime .handle() .spawn(async move { @@ -229,9 +229,9 @@ mod tests { let threads: Vec<_> = (0..num_threads) .map(|_| { let mut iter = iter.clone(); - let counter = counter.clone(); - let barrier = barrier.clone(); - let results = results.clone(); + let counter = Arc::clone(&counter); + let barrier = Arc::clone(&barrier); + let results = Arc::clone(&results); thread::spawn(move || { barrier.wait(); @@ -290,8 +290,8 @@ mod tests { let threads: Vec<_> = (0..num_threads) .map(|thread_id| { let iter = iter.clone(); - let collected = collected.clone(); - let barrier = barrier.clone(); + let collected = Arc::clone(&collected); + let barrier = Arc::clone(&barrier); thread::spawn(move || { barrier.wait(); @@ -346,11 +346,11 @@ mod tests { #[test] fn test_block_on_stream_drop_receivers_early() { let counter = Arc::new(AtomicUsize::new(0)); - let c = counter.clone(); + let c = Arc::clone(&counter); let mut iter = CurrentThreadRuntime::new().block_on_stream({ stream::unfold(0, move |state| { - let c = c.clone(); + let c = Arc::clone(&c); async move { (state < 100).then(|| { c.fetch_add(1, Ordering::SeqCst); @@ -382,7 +382,7 @@ mod tests { let iter1 = iter.clone(); let iter2 = iter; - let barrier1 = barrier.clone(); + let barrier1 = Arc::clone(&barrier); let barrier2 = barrier; let thread1 = thread::spawn(move || { @@ -441,8 +441,8 @@ mod tests { let threads: Vec<_> = (0..num_threads) .map(|_| { let iter = iter.clone(); - let received = received.clone(); - let barrier = barrier.clone(); + let received = Arc::clone(&received); + let barrier = Arc::clone(&barrier); thread::spawn(move || { barrier.wait(); diff --git a/vortex-io/src/runtime/handle.rs b/vortex-io/src/runtime/handle.rs index 4893c2e57e5..f04b897b29e 100644 --- a/vortex-io/src/runtime/handle.rs +++ b/vortex-io/src/runtime/handle.rs @@ -88,7 +88,7 @@ impl Handle { Fut: Future + Send + 'static, R: Send + 'static, { - self.spawn(f(Handle::new(self.runtime.clone()))) + self.spawn(f(Handle::new(Weak::clone(&self.runtime)))) } /// Spawn a CPU-bound task for execution on the runtime. diff --git a/vortex-io/src/runtime/pool.rs b/vortex-io/src/runtime/pool.rs index 962407551ec..a8d1f67a149 100644 --- a/vortex-io/src/runtime/pool.rs +++ b/vortex-io/src/runtime/pool.rs @@ -44,8 +44,8 @@ impl CurrentThreadWorkerPool { // Spawn new workers for _ in current..n { let shutdown = Arc::new(AtomicBool::new(false)); - let executor = self.executor.clone(); - let shutdown_clone = shutdown.clone(); + let executor = Arc::clone(&self.executor); + let shutdown_clone = Arc::clone(&shutdown); std::thread::Builder::new() .name("vortex-current-thread-worker".to_string()) diff --git a/vortex-io/src/runtime/single.rs b/vortex-io/src/runtime/single.rs index ea6a68f2f24..2a113e3715e 100644 --- a/vortex-io/src/runtime/single.rs +++ b/vortex-io/src/runtime/single.rs @@ -2,6 +2,7 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use std::rc::Rc; +use std::rc::Weak as RcWeak; use std::sync::Arc; use futures::Stream; @@ -53,7 +54,7 @@ impl Sender { let weak_local = Rc::downgrade(local); // Drive scheduling tasks. - let weak_local2 = weak_local.clone(); + let weak_local2 = RcWeak::clone(&weak_local); local .spawn(async move { while let Ok(spawn) = scheduling_recv.as_async().recv().await { @@ -70,7 +71,7 @@ impl Sender { .detach(); // Drive CPU tasks. - let weak_local2 = weak_local.clone(); + let weak_local2 = RcWeak::clone(&weak_local); local .spawn(async move { while let Ok(spawn) = cpu_recv.as_async().recv().await { @@ -86,7 +87,7 @@ impl Sender { .detach(); // Drive blocking tasks. - let weak_local2 = weak_local.clone(); + let weak_local2 = RcWeak::clone(&weak_local); local .spawn(async move { while let Ok(spawn) = blocking_recv.as_async().recv().await { @@ -158,7 +159,7 @@ impl BlockingRuntime for SingleThreadRuntime { type BlockingIterator<'a, R: 'a> = SingleThreadIterator<'a, R>; fn handle(&self) -> Handle { - let executor: Arc = self.sender.clone(); + let executor: Arc = Arc::clone(&self.sender) as Arc; Handle::new(Arc::downgrade(&executor)) } @@ -175,7 +176,7 @@ impl BlockingRuntime for SingleThreadRuntime { R: Send + 'a, { SingleThreadIterator { - executor: self.executor.clone(), + executor: Rc::clone(&self.executor), stream: stream.boxed_local(), } } @@ -277,7 +278,7 @@ mod tests { #[test] fn test_spawn_cpu_task() { let counter = Arc::new(AtomicUsize::new(0)); - let c = counter.clone(); + let c = Arc::clone(&counter); block_on(|handle| async move { handle diff --git a/vortex-io/src/runtime/tests.rs b/vortex-io/src/runtime/tests.rs index 12b685b820e..8b342f4242d 100644 --- a/vortex-io/src/runtime/tests.rs +++ b/vortex-io/src/runtime/tests.rs @@ -213,7 +213,7 @@ fn test_handle_spawn_future() { async fn test_handle_spawn_cpu() { let handle = TokioRuntime::current(); let counter = Arc::new(AtomicUsize::new(0)); - let c = counter.clone(); + let c = Arc::clone(&counter); let task = handle.spawn_cpu(move || { c.fetch_add(1, Ordering::SeqCst); @@ -278,7 +278,7 @@ async fn test_custom_vortex_read() { let read_at: Arc = Arc::new(CountingReadAt { data: ByteBuffer::from(TEST_DATA.to_vec()), - read_count: read_count.clone(), + read_count: Arc::clone(&read_count), }); // Perform several reads @@ -315,7 +315,7 @@ async fn test_read_out_of_bounds() { async fn test_task_detach() { let handle = TokioRuntime::current(); let counter = Arc::new(AtomicUsize::new(0)); - let c = counter.clone(); + let c = Arc::clone(&counter); let (tx, rx) = oneshot::channel::<()>(); let task = handle.spawn(async move { diff --git a/vortex-io/src/runtime/tokio.rs b/vortex-io/src/runtime/tokio.rs index 4e386718b83..4a014bb5ed0 100644 --- a/vortex-io/src/runtime/tokio.rs +++ b/vortex-io/src/runtime/tokio.rs @@ -118,7 +118,7 @@ impl BlockingRuntime for TokioRuntime { type BlockingIterator<'a, R: 'a> = TokioBlockingIterator<'a, R>; fn handle(&self) -> Handle { - let executor: Arc = self.0.clone(); + let executor: Arc = Arc::clone(&self.0) as Arc; Handle::new(Arc::downgrade(&executor)) } @@ -130,7 +130,7 @@ impl BlockingRuntime for TokioRuntime { if tokio::runtime::Handle::try_current().is_ok() { vortex_error::vortex_panic!("block_on cannot be called from within a Tokio runtime"); } - let handle = self.0.clone(); + let handle = Arc::clone(&self.0); tokio::task::block_in_place(move || handle.block_on(fut)) } @@ -145,7 +145,7 @@ impl BlockingRuntime for TokioRuntime { "block_on_stream cannot be called from within a Tokio runtime" ); } - let handle = self.0.clone(); + let handle = Arc::clone(&self.0); let stream = Box::pin(stream); TokioBlockingIterator { handle, stream } } @@ -197,7 +197,7 @@ mod tests { let runtime = TokioRuntime::from(tokio_rt.handle()); let counter = Arc::new(AtomicUsize::new(0)); - let c = counter.clone(); + let c = Arc::clone(&counter); // Create a channel to ensure the future doesn't complete immediately let (send, recv) = tokio::sync::oneshot::channel::<()>(); diff --git a/vortex-io/src/std_file/read_at.rs b/vortex-io/src/std_file/read_at.rs index 13d3b3f5501..2ae60ee5d28 100644 --- a/vortex-io/src/std_file/read_at.rs +++ b/vortex-io/src/std_file/read_at.rs @@ -91,7 +91,7 @@ impl VortexReadAt for FileReadAt { } fn size(&self) -> BoxFuture<'static, VortexResult> { - let file = self.file.clone(); + let file = Arc::clone(&self.file); async move { let metadata = file.metadata()?; Ok(metadata.len()) @@ -105,7 +105,7 @@ impl VortexReadAt for FileReadAt { length: usize, alignment: Alignment, ) -> BoxFuture<'static, VortexResult> { - let file = self.file.clone(); + let file = Arc::clone(&self.file); let handle = self.handle.clone(); async move { handle diff --git a/vortex-jni/src/array.rs b/vortex-jni/src/array.rs index c024188eeb7..c45f232b920 100644 --- a/vortex-jni/src/array.rs +++ b/vortex-jni/src/array.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::Arc; + use arrow_array::ffi::FFI_ArrowArray; use arrow_array::ffi::FFI_ArrowSchema; use arrow_schema::DataType; @@ -151,7 +153,7 @@ fn data_type_no_views(data_type: DataType) -> DataType { let viewless_fields: Vec = fields .iter() .map(|field_ref| { - let field = (*field_ref.clone()).clone(); + let field = (*Arc::clone(field_ref)).clone(); let data_type = field.data_type().clone(); let field = field.with_data_type(data_type_no_views(data_type)); FieldRef::new(field) diff --git a/vortex-jni/src/object_store.rs b/vortex-jni/src/object_store.rs index 141e00c211f..d982fd3ab29 100644 --- a/vortex-jni/src/object_store.rs +++ b/vortex-jni/src/object_store.rs @@ -40,7 +40,7 @@ pub(crate) fn make_object_store( { if let Some(cached) = OBJECT_STORES.lock().get(&cache_key) { - return Ok((cached.clone(), scheme)); + return Ok((Arc::clone(cached), scheme)); } // guard dropped at close of scope } @@ -129,7 +129,7 @@ pub(crate) fn make_object_store( }; { - OBJECT_STORES.lock().insert(cache_key, store.clone()); + OBJECT_STORES.lock().insert(cache_key, Arc::clone(&store)); // Guard dropped at close of scope. } diff --git a/vortex-layout/src/children.rs b/vortex-layout/src/children.rs index 7871e5bf151..2090aede5ee 100644 --- a/vortex-layout/src/children.rs +++ b/vortex-layout/src/children.rs @@ -43,7 +43,7 @@ impl Debug for dyn LayoutChildren { impl LayoutChildren for Arc { fn to_arc(&self) -> Arc { - self.clone() + Arc::clone(self) } fn child(&self, idx: usize, dtype: &DType) -> VortexResult { @@ -84,7 +84,7 @@ impl LayoutChildren for OwnedLayoutChildren { if child.dtype() != dtype { vortex_bail!("Child dtype mismatch: {} != {}", child.dtype(), dtype); } - Ok(child.clone()) + Ok(Arc::clone(child)) } fn child_row_count(&self, idx: usize) -> u64 { diff --git a/vortex-layout/src/display.rs b/vortex-layout/src/display.rs index 30e029ec8a3..a03481bce73 100644 --- a/vortex-layout/src/display.rs +++ b/vortex-layout/src/display.rs @@ -32,7 +32,7 @@ pub(super) async fn display_tree_with_segment_sizes( // Fetch segments in parallel and parse buffer info let fetch_futures = segments_to_fetch.iter().map(|&segment_id| { - let segment_source = segment_source.clone(); + let segment_source = Arc::clone(&segment_source); async move { let buffer = segment_source.request(segment_id).await?; let parts = SerializedArray::try_from(buffer)?; @@ -202,7 +202,7 @@ impl DisplayLayoutTree { impl std::fmt::Display for DisplayLayoutTree { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self.make_tree(self.layout.clone()) { + match self.make_tree(Arc::clone(&self.layout)) { Ok(tree) => write!(f, "{}", tree), Err(e) => write!(f, "Error building layout tree: {}", e), } @@ -264,7 +264,7 @@ mod tests { let layout1 = FlatLayoutStrategy::default() .write_stream( ctx.clone(), - segments.clone(), + Arc::::clone(&segments), array1.into_array().to_array_stream().sequenced(ptr1), eof1, handle.clone(), @@ -287,7 +287,7 @@ mod tests { let layout2 = FlatLayoutStrategy::default() .write_stream( ctx.clone(), - segments.clone(), + Arc::::clone(&segments), builder .finish() .into_array() @@ -351,7 +351,7 @@ vortex.struct, dtype: {numbers=i64?, strings=utf8}, children: 2, rows: 5 let layout1 = FlatLayoutStrategy::default() .write_stream( ctx.clone(), - segments.clone(), + Arc::::clone(&segments), array1.into_array().to_array_stream().sequenced(ptr1), eof1, handle.clone(), @@ -365,7 +365,7 @@ vortex.struct, dtype: {numbers=i64?, strings=utf8}, children: 2, rows: 5 let layout2 = FlatLayoutStrategy::default() .write_stream( ctx.clone(), - segments.clone(), + Arc::::clone(&segments), array2.into_array().to_array_stream().sequenced(ptr2), eof2, handle.clone(), @@ -410,7 +410,7 @@ vortex.chunked, dtype: i32, children: 2, rows: 10 FlatLayoutStrategy::default() .write_stream( ctx.clone(), - segments.clone(), + Arc::::clone(&segments), array.into_array().to_array_stream().sequenced(ptr), eof, handle, @@ -452,7 +452,7 @@ vortex.flat, dtype: i32?, segment 0, buffers=[20B], total=20B FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.into_array().to_array_stream().sequenced(ptr), eof, handle, diff --git a/vortex-layout/src/layout.rs b/vortex-layout/src/layout.rs index a4f9e6e0830..473d754df83 100644 --- a/vortex-layout/src/layout.rs +++ b/vortex-layout/src/layout.rs @@ -96,8 +96,8 @@ impl LayoutChildType { pub fn name(&self) -> Arc { match self { LayoutChildType::Chunk((idx, _offset)) => format!("[{idx}]").into(), - LayoutChildType::Auxiliary(name) => name.clone(), - LayoutChildType::Transparent(name) => name.clone(), + LayoutChildType::Auxiliary(name) => Arc::clone(name), + LayoutChildType::Transparent(name) => Arc::clone(name), LayoutChildType::Field(name) => name.clone().into(), } } @@ -463,7 +463,7 @@ mod tests { ]; for field_name in special_fields { - let field = LayoutChildType::Field(field_name.clone().into()); + let field = LayoutChildType::Field(Arc::clone(&field_name).into()); assert_eq!(field.name(), field_name); assert_eq!(field.row_offset(), Some(0)); } @@ -511,7 +511,8 @@ mod tests { ); // Create dict layout (column "name") - let dict_layout = DictLayout::new(dict_values.clone(), dict_codes.clone()).into_layout(); + let dict_layout = + DictLayout::new(Arc::clone(&dict_values), Arc::clone(&dict_codes)).into_layout(); // Test dict layout display (no direct segments) assert_eq!(format!("{}", dict_layout), "vortex.dict(utf8, rows=10)"); @@ -537,7 +538,10 @@ mod tests { let chunked_layout = ChunkedLayout::new( 10, DType::Primitive(PType::I64, NonNullable), - crate::OwnedLayoutChildren::layout_children(vec![chunk1.clone(), chunk2.clone()]), + crate::OwnedLayoutChildren::layout_children(vec![ + Arc::clone(&chunk1), + Arc::clone(&chunk2), + ]), ) .into_layout(); diff --git a/vortex-layout/src/layouts/buffered.rs b/vortex-layout/src/layouts/buffered.rs index dd1c432d697..6a8001fd397 100644 --- a/vortex-layout/src/layouts/buffered.rs +++ b/vortex-layout/src/layouts/buffered.rs @@ -52,7 +52,7 @@ impl LayoutStrategy for BufferedStrategy { let dtype = stream.dtype().clone(); let buffer_size = self.buffer_size; - let buffered_bytes_counter = self.buffered_bytes.clone(); + let buffered_bytes_counter = Arc::clone(&self.buffered_bytes); let buffered_stream = try_stream! { let stream = stream.peekable(); pin_mut!(stream); diff --git a/vortex-layout/src/layouts/chunked/reader.rs b/vortex-layout/src/layouts/chunked/reader.rs index 63e22e4a394..d284f2f4d5e 100644 --- a/vortex-layout/src/layouts/chunked/reader.rs +++ b/vortex-layout/src/layouts/chunked/reader.rs @@ -60,7 +60,7 @@ impl ChunkedReader { .map(|idx| Arc::from(format!("{name}.[{idx}]"))) .collect(); let lazy_children = LazyReaderChildren::new( - layout.children.clone(), + Arc::clone(&layout.children), dtypes, names, segment_source, @@ -227,7 +227,7 @@ impl LayoutReader for ChunkedReader { chunk_evals.push(chunk_eval); } - let name = self.name.clone(); + let name = Arc::clone(&self.name); Ok(MaskFuture::new(mask.len(), async move { tracing::debug!( "Chunked pruning evaluation {} (mask = {})", @@ -270,7 +270,7 @@ impl LayoutReader for ChunkedReader { chunk_evals.push(chunk_eval); } - let name = self.name.clone(); + let name = Arc::clone(&self.name); Ok(MaskFuture::new(mask.len(), async move { tracing::debug!("Chunked mask evaluation {}", name); @@ -366,7 +366,7 @@ mod test { let layout = block_on(|handle| { strategy.write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), SequentialStreamAdapter::new( DType::Primitive(PType::I32, NonNullable), stream::iter([ diff --git a/vortex-layout/src/layouts/chunked/writer.rs b/vortex-layout/src/layouts/chunked/writer.rs index 67970af124e..621159a2025 100644 --- a/vortex-layout/src/layouts/chunked/writer.rs +++ b/vortex-layout/src/layouts/chunked/writer.rs @@ -50,7 +50,7 @@ impl LayoutStrategy for ChunkedLayoutStrategy { ) -> VortexResult { let dtype = stream.dtype().clone(); let dtype2 = dtype.clone(); - let chunk_strategy = self.chunk_strategy.clone(); + let chunk_strategy = Arc::clone(&self.chunk_strategy); // We spawn each child to allow parallelism when processing chunks. let stream = stream! { @@ -58,9 +58,9 @@ impl LayoutStrategy for ChunkedLayoutStrategy { while let Some(chunk) = stream.next().await { let chunk_eof = eof.split_off(); - let chunk_strategy = chunk_strategy.clone(); + let chunk_strategy = Arc::clone(&chunk_strategy); let ctx = ctx.clone(); - let segment_sink = segment_sink.clone(); + let segment_sink = Arc::clone(&segment_sink); let dtype = dtype2.clone(); yield handle.spawn_nested(move |handle| async move { diff --git a/vortex-layout/src/layouts/compressed.rs b/vortex-layout/src/layouts/compressed.rs index 1d5dac46b6d..71a2834d610 100644 --- a/vortex-layout/src/layouts/compressed.rs +++ b/vortex-layout/src/layouts/compressed.rs @@ -85,12 +85,12 @@ impl LayoutStrategy for CompressingStrategy { handle: Handle, ) -> VortexResult { let dtype = stream.dtype().clone(); - let compressor = self.compressor.clone(); + let compressor = Arc::clone(&self.compressor); let handle2 = handle.clone(); let stream = stream .map(move |chunk| { - let compressor = compressor.clone(); + let compressor = Arc::clone(&compressor); handle2.spawn_cpu(move || { let (sequence_id, chunk) = chunk?; // Compute the stats for the chunk prior to compression diff --git a/vortex-layout/src/layouts/dict/mod.rs b/vortex-layout/src/layouts/dict/mod.rs index 1a7dac17efe..866cf6587e9 100644 --- a/vortex-layout/src/layouts/dict/mod.rs +++ b/vortex-layout/src/layouts/dict/mod.rs @@ -73,8 +73,8 @@ impl VTable for Dict { fn child(layout: &Self::Layout, idx: usize) -> VortexResult { match idx { - 0 => Ok(layout.values.clone()), - 1 => Ok(layout.codes.clone()), + 0 => Ok(Arc::clone(&layout.values)), + 1 => Ok(Arc::clone(&layout.codes)), _ => vortex_bail!("Unreachable child index: {}", idx), } } diff --git a/vortex-layout/src/layouts/dict/reader.rs b/vortex-layout/src/layouts/dict/reader.rs index d42c311e9de..65e9bfac3a6 100644 --- a/vortex-layout/src/layouts/dict/reader.rs +++ b/vortex-layout/src/layouts/dict/reader.rs @@ -61,7 +61,7 @@ impl DictReader { let values_len = usize::try_from(layout.values.row_count())?; let values = layout.values.new_reader( format!("{name}.values").into(), - segment_source.clone(), + Arc::clone(&segment_source), &session, )?; let codes = @@ -324,7 +324,7 @@ mod tests { let layout: LayoutRef = strategy .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), SequentialStreamAdapter::new( DType::Utf8(Nullability::Nullable), array_to_write.to_array_stream().sequenced(ptr), @@ -408,7 +408,7 @@ mod tests { let layout: LayoutRef = strategy .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), SequentialStreamAdapter::new( DType::Utf8(Nullability::Nullable), array.to_array_stream().sequenced(ptr), @@ -472,7 +472,7 @@ mod tests { let layout: LayoutRef = strategy .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), SequentialStreamAdapter::new( DType::Utf8(Nullability::Nullable), array_to_write.to_array_stream().sequenced(ptr), diff --git a/vortex-layout/src/layouts/dict/writer.rs b/vortex-layout/src/layouts/dict/writer.rs index 5d7a28f5083..fd51739d646 100644 --- a/vortex-layout/src/layouts/dict/writer.rs +++ b/vortex-layout/src/layouts/dict/writer.rs @@ -176,10 +176,10 @@ impl LayoutStrategy for DictStrategy { pin_mut!(runs); while let Some((codes_stream, values_fut)) = runs.next().await { - let codes = self.codes.clone(); + let codes = Arc::clone(&self.codes); let codes_eof = eof.split_off(); let ctx2 = ctx.clone(); - let segment_sink2 = segment_sink.clone(); + let segment_sink2 = Arc::clone(&segment_sink); let codes_fut = handle.spawn_nested(move |h| async move { codes.write_stream( ctx2, @@ -190,10 +190,10 @@ impl LayoutStrategy for DictStrategy { ).await }); - let values = self.values.clone(); + let values = Arc::clone(&self.values); let values_eof = eof.split_off(); let ctx2 = ctx.clone(); - let segment_sink2 = segment_sink.clone(); + let segment_sink2 = Arc::clone(&segment_sink); let dtype2 = dtype2.clone(); let values_layout = handle.spawn_nested(move |h| async move { values.write_stream( diff --git a/vortex-layout/src/layouts/flat/reader.rs b/vortex-layout/src/layouts/flat/reader.rs index 7922e1c1560..2b1bb4f1088 100644 --- a/vortex-layout/src/layouts/flat/reader.rs +++ b/vortex-layout/src/layouts/flat/reader.rs @@ -128,7 +128,7 @@ impl LayoutReader for FlatReader { .vortex_expect("Row range begin must fit within FlatLayout size") ..usize::try_from(row_range.end) .vortex_expect("Row range end must fit within FlatLayout size"); - let name = self.name.clone(); + let name = Arc::clone(&self.name); let array = self.array_future(); let expr = expr.clone(); let session = self.session.clone(); @@ -186,7 +186,7 @@ impl LayoutReader for FlatReader { .vortex_expect("Row range begin must fit within FlatLayout size") ..usize::try_from(row_range.end) .vortex_expect("Row range end must fit within FlatLayout size"); - let name = self.name.clone(); + let name = Arc::clone(&self.name); let array = self.array_future(); let expr = expr.clone(); @@ -254,7 +254,7 @@ mod test { let layout = FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.to_array_stream().sequenced(ptr), eof, handle, @@ -293,7 +293,7 @@ mod test { let layout = FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.to_array_stream().sequenced(ptr), eof, handle, @@ -330,7 +330,7 @@ mod test { let layout = FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.to_array_stream().sequenced(ptr), eof, handle, diff --git a/vortex-layout/src/layouts/flat/writer.rs b/vortex-layout/src/layouts/flat/writer.rs index 01e0d7760ab..b8cfa23d51e 100644 --- a/vortex-layout/src/layouts/flat/writer.rs +++ b/vortex-layout/src/layouts/flat/writer.rs @@ -247,7 +247,7 @@ mod tests { let layout = FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.into_array().to_array_stream().sequenced(ptr), eof, handle, @@ -296,7 +296,7 @@ mod tests { let layout = FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.into_array().to_array_stream().sequenced(ptr), eof, handle, @@ -363,7 +363,7 @@ mod tests { let layout = FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.into_array().to_array_stream().sequenced(ptr), eof, handle, @@ -430,7 +430,7 @@ mod tests { .with_allow_encodings(allowed) .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), filter.into_array().to_array_stream().sequenced(ptr), eof, handle, @@ -471,7 +471,7 @@ mod tests { .with_allow_encodings(allowed) .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), dict.into_array().to_array_stream().sequenced(ptr), eof, handle, diff --git a/vortex-layout/src/layouts/repartition.rs b/vortex-layout/src/layouts/repartition.rs index 74b1bde0e98..eac657bdf79 100644 --- a/vortex-layout/src/layouts/repartition.rs +++ b/vortex-layout/src/layouts/repartition.rs @@ -384,8 +384,15 @@ mod tests { ); let stream = fsl.into_array().to_array_stream().sequenced(ptr); - let layout = - block_on(|handle| strategy.write_stream(ctx, segments.clone(), stream, eof, handle))?; + let layout = block_on(|handle| { + strategy.write_stream( + ctx, + Arc::::clone(&segments), + stream, + eof, + handle, + ) + })?; // The layout should be a ChunkedLayout with multiple children. // With 1000 rows and effective block_len = 132: @@ -439,8 +446,15 @@ mod tests { ); let stream = elements.into_array().to_array_stream().sequenced(ptr); - let layout = - block_on(|handle| strategy.write_stream(ctx, segments.clone(), stream, eof, handle))?; + let layout = block_on(|handle| { + strategy.write_stream( + ctx, + Arc::::clone(&segments), + stream, + eof, + handle, + ) + })?; assert_eq!(layout.row_count(), num_elements as u64); assert_eq!(layout.nchildren(), 2); diff --git a/vortex-layout/src/layouts/row_idx/mod.rs b/vortex-layout/src/layouts/row_idx/mod.rs index 0e982ad2168..97ed6aa601a 100644 --- a/vortex-layout/src/layouts/row_idx/mod.rs +++ b/vortex-layout/src/layouts/row_idx/mod.rs @@ -55,7 +55,7 @@ pub struct RowIdxLayoutReader { impl RowIdxLayoutReader { pub fn new(row_offset: u64, child: Arc, session: VortexSession) -> Self { Self { - name: child.name().clone(), + name: Arc::clone(child.name()), row_offset, child, partition_cache: DashMap::with_hasher(Default::default()), @@ -205,7 +205,7 @@ impl LayoutReader for RowIdxLayoutReader { // during the filter evaluation. Partitioning::RowIdx(_) => Ok(mask), Partitioning::Child(expr) => self.child.filter_evaluation(row_range, expr, mask), - Partitioning::Partitioned(p) => p.clone().into_mask_future( + Partitioning::Partitioned(p) => Arc::clone(p).into_mask_future( mask, |annotation, expr, mask| match annotation { Partition::RowIdx => Ok(row_idx_mask_future( @@ -240,13 +240,12 @@ impl LayoutReader for RowIdxLayoutReader { } Partitioning::Child(expr) => self.child.projection_evaluation(row_range, expr, mask), Partitioning::Partitioned(p) => { - p.clone() - .into_array_future(mask, |annotation, expr, mask| match annotation { - Partition::RowIdx => { - Ok(row_idx_array_future(self.row_offset, row_range, expr, mask)) - } - Partition::Child => self.child.projection_evaluation(row_range, expr, mask), - }) + Arc::clone(p).into_array_future(mask, |annotation, expr, mask| match annotation { + Partition::RowIdx => { + Ok(row_idx_array_future(self.row_offset, row_range, expr, mask)) + } + Partition::Child => self.child.projection_evaluation(row_range, expr, mask), + }) } } } @@ -337,7 +336,7 @@ mod tests { let layout = FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.to_array_stream().sequenced(ptr), eof, handle, @@ -377,7 +376,7 @@ mod tests { let layout = FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.to_array_stream().sequenced(ptr), eof, handle, @@ -417,7 +416,7 @@ mod tests { let layout = FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), array.to_array_stream().sequenced(ptr), eof, handle, diff --git a/vortex-layout/src/layouts/struct_/reader.rs b/vortex-layout/src/layouts/struct_/reader.rs index e8ebb3dc1ad..6216388426d 100644 --- a/vortex-layout/src/layouts/struct_/reader.rs +++ b/vortex-layout/src/layouts/struct_/reader.rs @@ -84,7 +84,7 @@ impl StructReader { let mut names: Vec> = struct_dt .names() .iter() - .map(|x| x.inner().clone()) + .map(|x| Arc::clone(x.inner())) .collect(); if layout.dtype.is_nullable() { @@ -93,10 +93,10 @@ impl StructReader { } let lazy_children = LazyReaderChildren::new( - layout.children.clone(), + Arc::clone(&layout.children), dtypes, names, - segment_source.clone(), + Arc::clone(&segment_source), session.clone(), ); @@ -294,7 +294,7 @@ impl LayoutReader for StructReader { .map_err(|err| { err.with_context(format!("While evaluating filter partition {name}")) }), - Partitioned::Multi(partitioned) => partitioned.clone().into_mask_future( + Partitioned::Multi(partitioned) => Arc::clone(partitioned).into_mask_future( mask, |name, expr, mask| { self.field_reader(name)? @@ -340,17 +340,15 @@ impl LayoutReader for StructReader { ), Partitioned::Multi(partitioned) => ( - partitioned - .clone() - .into_array_future(mask_fut, |name, expr, mask| { - self.field_reader(name)? - .projection_evaluation(row_range, expr, mask) - .map_err(|err| { - err.with_context(format!( - "While evaluating projection partition {name}" - )) - }) - })?, + Arc::clone(partitioned).into_array_future(mask_fut, |name, expr, mask| { + self.field_reader(name)? + .projection_evaluation(row_range, expr, mask) + .map_err(|err| { + err.with_context(format!( + "While evaluating projection partition {name}" + )) + }) + })?, partitioned.root.is::() || partitioned.root.is::(), ), }; @@ -446,7 +444,7 @@ mod tests { let layout = block_on(|handle| { strategy.write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), StructArray::try_new( Vec::::new().into(), vec![], @@ -479,7 +477,7 @@ mod tests { let layout = block_on(|handle| { strategy.write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), StructArray::from_fields( [ ("a", buffer![7, 2, 3].into_array()), @@ -515,7 +513,7 @@ mod tests { let layout = block_on(|handle| { strategy.write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), StructArray::try_from_iter_with_validity( [ ("a", buffer![7, 2, 3].into_array()), @@ -556,7 +554,7 @@ mod tests { let layout = block_on(|handle| { strategy.write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), StructArray::try_from_iter_with_validity( [( "a", diff --git a/vortex-layout/src/layouts/table.rs b/vortex-layout/src/layouts/table.rs index ff068bf6e8e..1a0aacc5f0a 100644 --- a/vortex-layout/src/layouts/table.rs +++ b/vortex-layout/src/layouts/table.rs @@ -70,7 +70,7 @@ impl TableStrategy { /// // Build a write strategy that does not compress validity or any leaf fields. /// let flat = Arc::new(FlatLayoutStrategy::default()); /// - /// let strategy = TableStrategy::new(flat.clone(), flat.clone()); + /// let strategy = TableStrategy::new(Arc::::clone(&flat), Arc::::clone(&flat)); /// ``` pub fn new(validity: Arc, fallback: Arc) -> Self { Self { @@ -156,14 +156,14 @@ impl TableStrategy { if field_path.starts_with_field(field) && let Some(subpath) = field_path.clone().step_into() { - new_writers.insert(subpath, strategy.clone()); + new_writers.insert(subpath, Arc::clone(strategy)); } } Self { leaf_writers: new_writers, - validity: self.validity.clone(), - fallback: self.fallback.clone(), + validity: Arc::clone(&self.validity), + fallback: Arc::clone(&self.fallback), } } @@ -274,7 +274,7 @@ impl LayoutStrategy for TableStrategy { Err(e) => { let e: Arc = Arc::new(e); for tx in column_streams_tx.iter() { - let _ = tx.send(Err(VortexError::from(e.clone()))).await; + let _ = tx.send(Err(VortexError::from(Arc::clone(&e)))).await; } break; } @@ -312,7 +312,7 @@ impl LayoutStrategy for TableStrategy { let child_eof = eof.split_off(); let field = Field::Name(name.clone()); handle.spawn_nested(|h| { - let validity = self.validity.clone(); + let validity = Arc::clone(&self.validity); // descend further and try with new fields let writer = self .leaf_writers @@ -324,11 +324,11 @@ impl LayoutStrategy for TableStrategy { Arc::new(self.descend(&field)) } else { // Use fallback for leaf columns - self.fallback.clone() + Arc::clone(&self.fallback) } }); let ctx = ctx.clone(); - let segment_sink = segment_sink.clone(); + let segment_sink = Arc::clone(&segment_sink); async move { // If we have a matching writer, we use it. @@ -375,8 +375,11 @@ mod tests { let flat = Arc::new(FlatLayoutStrategy::default()); // Success - let path = TableStrategy::new(flat.clone(), flat.clone()) - .with_field_writer(field_path!(a.b.c), flat.clone()); + let path = TableStrategy::new( + Arc::::clone(&flat), + Arc::::clone(&flat), + ) + .with_field_writer(field_path!(a.b.c), Arc::::clone(&flat)); // Should panic right here. let _path = path.with_field_writer(field_path!(a.b), flat); @@ -388,7 +391,10 @@ mod tests { )] fn test_root_override() { let flat = Arc::new(FlatLayoutStrategy::default()); - let _strategy = TableStrategy::new(flat.clone(), flat.clone()) - .with_field_writer(FieldPath::root(), flat); + let _strategy = TableStrategy::new( + Arc::::clone(&flat), + Arc::::clone(&flat), + ) + .with_field_writer(FieldPath::root(), flat); } } diff --git a/vortex-layout/src/layouts/zoned/mod.rs b/vortex-layout/src/layouts/zoned/mod.rs index bcd4cf6699b..5167025ff3a 100644 --- a/vortex-layout/src/layouts/zoned/mod.rs +++ b/vortex-layout/src/layouts/zoned/mod.rs @@ -64,7 +64,7 @@ impl VTable for Zoned { fn metadata(layout: &Self::Layout) -> Self::Metadata { ZonedMetadata { zone_len: u32::try_from(layout.zone_len).vortex_expect("Invalid zone length"), - present_stats: layout.present_stats.clone(), + present_stats: Arc::clone(&layout.present_stats), } } @@ -122,7 +122,7 @@ impl VTable for Zoned { dtype: dtype.clone(), children: children.to_arc(), zone_len: metadata.zone_len as usize, - present_stats: metadata.present_stats.clone(), + present_stats: Arc::clone(&metadata.present_stats), }) } diff --git a/vortex-layout/src/layouts/zoned/reader.rs b/vortex-layout/src/layouts/zoned/reader.rs index 02bff672eeb..cef2370afdf 100644 --- a/vortex-layout/src/layouts/zoned/reader.rs +++ b/vortex-layout/src/layouts/zoned/reader.rs @@ -73,12 +73,12 @@ impl ZonedReader { layout.dtype.clone(), ZoneMap::dtype_for_stats_table(layout.dtype(), layout.present_stats()), ]; - let names = vec![name.clone(), format!("{}.zones", name).into()]; + let names = vec![Arc::clone(&name), format!("{}.zones", name).into()]; let lazy_children = LazyReaderChildren::new( - layout.children.clone(), + Arc::clone(&layout.children), dtypes, names, - segment_source.clone(), + Arc::clone(&segment_source), session.clone(), ); @@ -122,7 +122,7 @@ impl ZonedReader { self.zone_map .get_or_init(move || { let nzones = self.layout.nzones(); - let present_stats = self.layout.present_stats.clone(); + let present_stats = Arc::clone(&self.layout.present_stats); let zones_eval = self .lazy_children @@ -271,7 +271,7 @@ impl LayoutReader for ZonedReader { }) .try_collect()?; - let name = self.name.clone(); + let name = Arc::clone(&self.name); let expr = expr.clone(); Ok(MaskFuture::new(mask.len(), async move { @@ -444,7 +444,13 @@ mod test { .to_array_stream() .sequenced(ptr); let layout = block_on(|handle| { - strategy.write_stream(ctx, segments.clone(), array_stream, eof, handle) + strategy.write_stream( + ctx, + Arc::::clone(&segments), + array_stream, + eof, + handle, + ) }) .unwrap(); (segments, layout) diff --git a/vortex-layout/src/layouts/zoned/writer.rs b/vortex-layout/src/layouts/zoned/writer.rs index f6850826339..baa5fe4d61a 100644 --- a/vortex-layout/src/layouts/zoned/writer.rs +++ b/vortex-layout/src/layouts/zoned/writer.rs @@ -79,7 +79,7 @@ impl LayoutStrategy for ZonedStrategy { mut eof: SequencePointer, handle: Handle, ) -> VortexResult { - let stats = self.options.stats.clone(); + let stats = Arc::clone(&self.options.stats); let handle2 = handle.clone(); let stats_accumulator = Arc::new(Mutex::new(StatsAccumulator::new( @@ -93,7 +93,7 @@ impl LayoutStrategy for ZonedStrategy { stream.dtype().clone(), stream .map(move |chunk| { - let stats = stats.clone(); + let stats = Arc::clone(&stats); handle2.spawn_cpu(move || { let (sequence_id, chunk) = chunk?; chunk.statistics().compute_all(&stats)?; @@ -106,7 +106,7 @@ impl LayoutStrategy for ZonedStrategy { // Now we accumulate the stats we computed above, this time we cannot spawn because we // need to feed the accumulator an ordered stream. - let stats_accumulator2 = stats_accumulator.clone(); + let stats_accumulator2 = Arc::clone(&stats_accumulator); let stream = SequentialStreamAdapter::new( stream.dtype().clone(), stream.map(move |item| { @@ -128,7 +128,7 @@ impl LayoutStrategy for ZonedStrategy { .child .write_stream( ctx.clone(), - segment_sink.clone(), + Arc::clone(&segment_sink), stream, data_eof, handle.clone(), @@ -151,14 +151,14 @@ impl LayoutStrategy for ZonedStrategy { .sequenced(eof.split_off()); let zones_layout = self .stats - .write_stream(ctx, segment_sink.clone(), stats_stream, eof, handle) + .write_stream(ctx, Arc::clone(&segment_sink), stats_stream, eof, handle) .await?; Ok(ZonedLayout::new( data_layout, zones_layout, block_size, - stats_table.present_stats().clone(), + Arc::clone(stats_table.present_stats()), ) .into_layout()) } diff --git a/vortex-layout/src/reader.rs b/vortex-layout/src/reader.rs index 9ccd695c572..e103c163efe 100644 --- a/vortex-layout/src/reader.rs +++ b/vortex-layout/src/reader.rs @@ -145,7 +145,7 @@ impl LazyReaderChildren { let child = self.children.child(idx, dtype)?; child.new_reader( Arc::clone(&self.names[idx]), - self.segment_source.clone(), + Arc::clone(&self.segment_source), &self.session, ) }) diff --git a/vortex-layout/src/scan/arrow.rs b/vortex-layout/src/scan/arrow.rs index 2a17a81e6f8..875db04e4df 100644 --- a/vortex-layout/src/scan/arrow.rs +++ b/vortex-layout/src/scan/arrow.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use std::sync::Arc; + use arrow_array::RecordBatch; use arrow_array::RecordBatchReader; use arrow_array::cast::AsArray; @@ -104,7 +106,7 @@ where { #[inline] fn schema(&self) -> SchemaRef { - self.schema.clone() + Arc::clone(&self.schema) } } @@ -195,14 +197,14 @@ mod tests { fn test_record_batch_iterator_adapter() -> VortexResult<()> { let schema = create_arrow_schema(); let batch1 = RecordBatch::try_new( - schema.clone(), + Arc::clone(&schema), vec![ Arc::new(Int32Array::from(vec![Some(1), Some(2)])) as ArrowArrayRef, Arc::new(StringArray::from(vec![Some("Alice"), Some("Bob")])) as ArrowArrayRef, ], )?; let batch2 = RecordBatch::try_new( - schema.clone(), + Arc::clone(&schema), vec![ Arc::new(Int32Array::from(vec![None, Some(4)])) as ArrowArrayRef, Arc::new(StringArray::from(vec![Some("Charlie"), None])) as ArrowArrayRef, @@ -212,7 +214,7 @@ mod tests { let iter = vec![Ok(batch1), Ok(batch2)].into_iter(); let mut adapter = RecordBatchIteratorAdapter { iter, - schema: schema.clone(), + schema: Arc::clone(&schema), }; // Test RecordBatchReader trait @@ -238,7 +240,7 @@ mod tests { let iter = vec![Err(error)].into_iter(); let mut adapter = RecordBatchIteratorAdapter { iter, - schema: schema.clone(), + schema: Arc::clone(&schema), }; // Test that error is propagated @@ -251,7 +253,7 @@ mod tests { fn test_mixed_success_and_error() { let schema = create_arrow_schema(); let batch = RecordBatch::try_new( - schema.clone(), + Arc::clone(&schema), vec![ Arc::new(Int32Array::from(vec![Some(1)])) as ArrowArrayRef, Arc::new(StringArray::from(vec![Some("Test")])) as ArrowArrayRef, diff --git a/vortex-layout/src/scan/layout.rs b/vortex-layout/src/scan/layout.rs index ab26a534f99..4ffdadab2e6 100644 --- a/vortex-layout/src/scan/layout.rs +++ b/vortex-layout/src/scan/layout.rs @@ -158,7 +158,7 @@ impl DataSource for LayoutReaderDataSource { } Ok(Box::new(LayoutReaderScan { - reader: self.reader.clone(), + reader: Arc::clone(&self.reader), session: self.session.clone(), dtype, projection: scan_request.projection, @@ -246,7 +246,7 @@ impl Stream for LayoutReaderScan { } let split = Box::new(LayoutReaderSplit { - reader: this.reader.clone(), + reader: Arc::clone(&this.reader), session: this.session.clone(), projection: this.projection.clone(), filter: this.filter.clone(), diff --git a/vortex-layout/src/scan/multi.rs b/vortex-layout/src/scan/multi.rs index e7fc803c38b..307aca187cc 100644 --- a/vortex-layout/src/scan/multi.rs +++ b/vortex-layout/src/scan/multi.rs @@ -204,8 +204,8 @@ impl DataSource for MultiLayoutDataSource { for child in &self.children { match child { - MultiLayoutChild::Opened(reader) => ready.push_back(reader.clone()), - MultiLayoutChild::Deferred(factory) => deferred.push_back(factory.clone()), + MultiLayoutChild::Opened(reader) => ready.push_back(Arc::clone(reader)), + MultiLayoutChild::Deferred(factory) => deferred.push_back(Arc::clone(factory)), } } diff --git a/vortex-layout/src/scan/repeated_scan.rs b/vortex-layout/src/scan/repeated_scan.rs index ec050ba520a..1d5caaa66cf 100644 --- a/vortex-layout/src/scan/repeated_scan.rs +++ b/vortex-layout/src/scan/repeated_scan.rs @@ -124,9 +124,9 @@ impl RepeatedScan { let ctx = Arc::new(TaskContext { selection: self.selection.clone(), filter: self.filter.clone().map(|f| Arc::new(FilterExpr::new(f))), - reader: self.layout_reader.clone(), + reader: Arc::clone(&self.layout_reader), projection: self.projection.clone(), - mapper: self.map_fn.clone(), + mapper: Arc::clone(&self.map_fn), }); let row_range = intersect_ranges(self.row_range.as_ref(), row_range); @@ -176,7 +176,7 @@ impl RepeatedScan { break; } - tasks.push(split_exec(ctx.clone(), range, limit.as_mut())?); + tasks.push(split_exec(Arc::clone(&ctx), range, limit.as_mut())?); } Ok(tasks) diff --git a/vortex-layout/src/scan/scan_builder.rs b/vortex-layout/src/scan/scan_builder.rs index af179bc670d..d53a38163fa 100644 --- a/vortex-layout/src/scan/scan_builder.rs +++ b/vortex-layout/src/scan/scan_builder.rs @@ -559,7 +559,7 @@ mod test { #[test] fn into_stream_is_lazy() { let calls = Arc::new(AtomicUsize::new(0)); - let reader = Arc::new(CountingLayoutReader::new(calls.clone())); + let reader = Arc::new(CountingLayoutReader::new(Arc::clone(&calls))); let session = crate::scan::test::SCAN_SESSION.clone(); @@ -654,7 +654,7 @@ mod test { #[test] fn into_stream_executes_after_prepare() -> VortexResult<()> { let calls = Arc::new(AtomicUsize::new(0)); - let reader = Arc::new(SplittingLayoutReader::new(calls.clone())); + let reader = Arc::new(SplittingLayoutReader::new(Arc::clone(&calls))); let runtime = SingleThreadRuntime::default(); let session = crate::scan::test::session_with_handle(runtime.handle()); @@ -755,7 +755,10 @@ mod test { let guard = gate.lock(); let calls = Arc::new(AtomicUsize::new(0)); - let reader = Arc::new(BlockingSplitsLayoutReader::new(gate.clone(), calls.clone())); + let reader = Arc::new(BlockingSplitsLayoutReader::new( + Arc::clone(&gate), + Arc::clone(&calls), + )); let runtime = SingleThreadRuntime::default(); let session = crate::scan::test::session_with_handle(runtime.handle()); diff --git a/vortex-layout/src/scan/split_by.rs b/vortex-layout/src/scan/split_by.rs index 712f9e5bb4f..bd63f349949 100644 --- a/vortex-layout/src/scan/split_by.rs +++ b/vortex-layout/src/scan/split_by.rs @@ -78,7 +78,7 @@ mod test { FlatLayoutStrategy::default() .write_stream( ctx, - segments.clone(), + Arc::::clone(&segments), buffer![1_i32; 10] .into_array() .to_array_stream() diff --git a/vortex-layout/src/scan/tasks.rs b/vortex-layout/src/scan/tasks.rs index 056d8451882..dc0b489b1f2 100644 --- a/vortex-layout/src/scan/tasks.rs +++ b/vortex-layout/src/scan/tasks.rs @@ -71,8 +71,8 @@ pub fn split_exec( // NOTE: it's very important that the pruning and filter evaluations are built OUTSIDE // the future. Registering these row ranges eagerly is a hint to the IO system that // we want to start prefetching the IO for this split. - let reader = ctx.reader.clone(); - let filter = filter.clone(); + let reader = Arc::clone(&ctx.reader); + let filter = Arc::clone(filter); let row_range = row_range.clone(); MaskFuture::new(row_mask.len(), async move { @@ -141,7 +141,7 @@ pub fn split_exec( ctx.reader .projection_evaluation(&row_range, &ctx.projection, filter_mask.clone())?; - let mapper = ctx.mapper.clone(); + let mapper = Arc::clone(&ctx.mapper); let array_fut = async move { let mask = filter_mask.await?; if mask.all_false() { diff --git a/vortex-layout/src/segments/cache.rs b/vortex-layout/src/segments/cache.rs index 174c6b1e637..37675c19d2a 100644 --- a/vortex-layout/src/segments/cache.rs +++ b/vortex-layout/src/segments/cache.rs @@ -137,7 +137,7 @@ impl SegmentCacheSourceAdapter { impl SegmentSource for SegmentCacheSourceAdapter { fn request(&self, id: SegmentId) -> SegmentFuture { - let cache = self.cache.clone(); + let cache = Arc::clone(&self.cache); let delegate = self.source.request(id); async move { diff --git a/vortex-layout/src/sequence.rs b/vortex-layout/src/sequence.rs index fa847e50730..5e9b8b0495d 100644 --- a/vortex-layout/src/sequence.rs +++ b/vortex-layout/src/sequence.rs @@ -101,7 +101,7 @@ impl SequenceId { pub fn descend(self) -> SequencePointer { let mut id = self.id.clone(); id.push(0); - SequencePointer(SequenceId::new(id, self.universe.clone())) + SequencePointer(SequenceId::new(id, Arc::clone(&self.universe))) } /// Waits until all SequenceIds with IDs lexicographically smaller than this one are dropped. @@ -187,7 +187,7 @@ impl SequencePointer { let last = next_id.last_mut(); let last = last.vortex_expect("must have at least one element"); *last += 1; - let next_sibling = SequenceId::new(next_id, self.0.universe.clone()); + let next_sibling = SequenceId::new(next_id, Arc::clone(&self.0.universe)); std::mem::replace(&mut self.0, next_sibling) } diff --git a/vortex-python/src/dataset.rs b/vortex-python/src/dataset.rs index 1985f0b3141..dccb103037d 100644 --- a/vortex-python/src/dataset.rs +++ b/vortex-python/src/dataset.rs @@ -131,7 +131,7 @@ impl PyVortexDataset { #[pymethods] impl PyVortexDataset { fn schema(self_: PyRef) -> PyResult> { - self_.schema.clone().to_pyarrow(self_.py()) + Arc::clone(&self_.schema).to_pyarrow(self_.py()) } #[pyo3(signature = (*, columns = None, row_filter = None, indices = None, row_range = None))] diff --git a/vortex-python/src/scalar/factory.rs b/vortex-python/src/scalar/factory.rs index d4a0e000cf1..ea07d3494a9 100644 --- a/vortex-python/src/scalar/factory.rs +++ b/vortex-python/src/scalar/factory.rs @@ -183,7 +183,11 @@ fn scalar_helper_inner(value: &Bound<'_, PyAny>, dtype: Option<&DType>) -> PyRes .iter() .map(|e| scalar_helper_inner(&e, Some(element_dtype))) .try_collect()?; - Scalar::list(element_dtype.clone(), elements, Nullability::NonNullable); + Scalar::list( + Arc::clone(element_dtype), + elements, + Nullability::NonNullable, + ); } else { // If no dtype was provided, we need to infer the element dtype from the list contents. // We do this in a greedy way taking the first element dtype we find. diff --git a/vortex-test/compat-gen/src/adapter.rs b/vortex-test/compat-gen/src/adapter.rs index 21f203e53e4..9e29d6d69f0 100644 --- a/vortex-test/compat-gen/src/adapter.rs +++ b/vortex-test/compat-gen/src/adapter.rs @@ -121,7 +121,7 @@ pub fn read_layout_tree(bytes: ByteBuffer) -> VortexResult<()> { runtime()?.block_on(async { let session = VortexSession::default().with_tokio(); let file = session.open_options().open_buffer(bytes)?; - let root_layout = file.footer().layout().clone(); + let root_layout = Arc::clone(file.footer().layout()); let segment_source = file.segment_source(); for layout_result in root_layout.depth_first_traversal() { @@ -133,7 +133,7 @@ pub fn read_layout_tree(bytes: ByteBuffer) -> VortexResult<()> { if row_count == 0 { continue; } - let reader = layout.new_reader("".into(), segment_source.clone(), &session)?; + let reader = layout.new_reader("".into(), Arc::clone(&segment_source), &session)?; let len = usize::try_from(row_count).map_err(|e| vortex_err!("row count overflow: {e}"))?; reader diff --git a/vortex-test/compat-gen/src/fixtures/arrays/datasets/clickbench.rs b/vortex-test/compat-gen/src/fixtures/arrays/datasets/clickbench.rs index 7959f475c6b..7cae6944463 100644 --- a/vortex-test/compat-gen/src/fixtures/arrays/datasets/clickbench.rs +++ b/vortex-test/compat-gen/src/fixtures/arrays/datasets/clickbench.rs @@ -3,6 +3,7 @@ use std::fs; use std::path::PathBuf; +use std::sync::Arc; use arrow_array::RecordBatch; use bytes::Bytes; @@ -95,7 +96,7 @@ fn sample_and_write(source_bytes: &[u8], dest: &std::path::Path) -> VortexResult let source_bytes = Bytes::copy_from_slice(source_bytes); let builder = ParquetRecordBatchReaderBuilder::try_new(source_bytes.clone()) .map_err(|e| vortex_err!("failed to open source parquet: {e}"))?; - let metadata = builder.metadata().clone(); + let metadata = Arc::clone(builder.metadata()); let total_rows: usize = metadata .row_groups() diff --git a/vortex-tui/src/browse/app.rs b/vortex-tui/src/browse/app.rs index 340f19fbed6..0a7f13ab277 100644 --- a/vortex-tui/src/browse/app.rs +++ b/vortex-tui/src/browse/app.rs @@ -61,7 +61,7 @@ impl LayoutCursor { pub fn new(footer: Footer, segment_source: Arc) -> Self { Self { path: Vec::new(), - layout: footer.layout().clone(), + layout: Arc::clone(footer.layout()), segment_map: Arc::clone(footer.segment_map()), footer, segment_source, @@ -76,7 +76,7 @@ impl LayoutCursor { segment_source: Arc, path: Vec, ) -> Self { - let mut layout = footer.layout().clone(); + let mut layout = Arc::clone(footer.layout()); // Traverse the layout tree at each element of the path. for component in path.iter().copied() { @@ -99,7 +99,7 @@ impl LayoutCursor { let mut path = self.path.clone(); path.push(n); - Self::new_with_path(self.footer.clone(), self.segment_source.clone(), path) + Self::new_with_path(self.footer.clone(), Arc::clone(&self.segment_source), path) } /// Create a new cursor pointing at the parent of the current layout. @@ -109,7 +109,7 @@ impl LayoutCursor { let mut path = self.path.clone(); path.pop(); - Self::new_with_path(self.footer.clone(), self.segment_source.clone(), path) + Self::new_with_path(self.footer.clone(), Arc::clone(&self.segment_source), path) } /// Get a human-readable description of the flat layout metadata. @@ -355,7 +355,7 @@ impl AppState { use vortex::array::serde::SerializedArray; use vortex::expr::root; - let layout = &self.cursor.layout().clone(); + let layout = &Arc::clone(self.cursor.layout()); let row_count = layout.row_count(); // Load the array. diff --git a/vortex-tui/src/inspect.rs b/vortex-tui/src/inspect.rs index d2258e59a4d..bc2e920aea4 100644 --- a/vortex-tui/src/inspect.rs +++ b/vortex-tui/src/inspect.rs @@ -210,8 +210,8 @@ async fn exec_inspect_json( let footer_json = if matches!(mode, InspectMode::Footer) && eof.valid_magic && postscript_json.is_some() { inspector.read_footer().await.ok().map(|footer| { - let segment_map = footer.segment_map().clone(); - let root_layout = footer.layout().clone(); + let segment_map = Arc::clone(footer.segment_map()); + let root_layout = Arc::clone(footer.layout()); let mut segment_paths: Vec>>> = vec![None; segment_map.len()]; let mut queue = @@ -538,14 +538,14 @@ impl FooterSegments { println!("\nSegment details:\n"); - let segment_map = self.0.segment_map().clone(); + let segment_map = Arc::clone(self.0.segment_map()); if segment_map.is_empty() { println!(""); return; } let mut segment_paths: Vec>>> = vec![None; segment_map.len()]; - let root_layout = self.0.layout().clone(); + let root_layout = Arc::clone(self.0.layout()); let mut queue = VecDeque::<(Vec>, LayoutRef)>::from_iter([(Vec::new(), root_layout)]); diff --git a/vortex-tui/src/tree.rs b/vortex-tui/src/tree.rs index a8799afea1e..27218d1d8db 100644 --- a/vortex-tui/src/tree.rs +++ b/vortex-tui/src/tree.rs @@ -5,6 +5,7 @@ use std::path::Path; use std::path::PathBuf; +use std::sync::Arc; use serde::Serialize; use vortex::array::stream::ArrayStreamExt; @@ -115,7 +116,7 @@ async fn exec_layout_tree( let footer = vxf.footer(); if json { - let tree = layout_to_json(footer.layout().clone())?; + let tree = layout_to_json(Arc::clone(footer.layout()))?; let json_output = serde_json::to_string_pretty(&tree) .map_err(|e| vortex::error::vortex_err!("Failed to serialize JSON: {e}"))?; println!("{json_output}"); diff --git a/vortex-utils/src/env.rs b/vortex-utils/src/env.rs index 9c4505ea443..19e78e1f12b 100644 --- a/vortex-utils/src/env.rs +++ b/vortex-utils/src/env.rs @@ -166,7 +166,7 @@ mod tests { let key = "VORTEX_TEST_ENV_VAR_WAIT"; let second_acquired = Arc::new(AtomicBool::new(false)); - let second_acquired_clone = second_acquired.clone(); + let second_acquired_clone = Arc::clone(&second_acquired); // First guard in main thread let _guard1 = EnvVarGuard::set(key, "first"); diff --git a/vortex/examples/tracing_vortex.rs b/vortex/examples/tracing_vortex.rs index ab4920e0f89..8d7dd6b2701 100644 --- a/vortex/examples/tracing_vortex.rs +++ b/vortex/examples/tracing_vortex.rs @@ -198,7 +198,7 @@ impl VortexLayer { let handle = WriterHandle::spawn(session, rx, output_dir, batch_size); ( Self { - sender: signal.clone(), + sender: Arc::clone(&signal), }, handle, ShutdownSignal { inner: signal },