This is an automated email from the ASF dual-hosted git repository.
scovich pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/main by this push:
new 53a16144b1 Remove unnecessary Arc<ArrayRef> (#9316)
53a16144b1 is described below
commit 53a16144b1a5cfde183c270284ea3b3cf5176521
Author: Ryan Johnson <[email protected]>
AuthorDate: Mon Feb 2 21:24:51 2026 -0700
Remove unnecessary Arc<ArrayRef> (#9316)
# Which issue does this PR close?
- Related to https://github.com/apache/arrow-rs/issues/8794
# Rationale for this change
Because `Arc<dyn Array>` (ArrayRef) implements `Array`, it's easy to
create redundant `Arc<Arc<dyn Array>>`. The extra indirection is pure
overhead (both cognitive and runtime) with no benefit.
# What changes are included in this PR?
Remove the redundant wrapping.
# Are these changes tested?
Compilation suffices -- failing to wrap a concrete array type in Arc
would cause compilation failures.
# Are there any user-facing changes?
No.
---
arrow-arith/src/temporal.rs | 1 -
arrow-cast/src/cast/mod.rs | 8 ++---
arrow-cast/src/cast/run_array.rs | 2 +-
arrow-ipc/src/reader.rs | 4 +--
arrow-ord/src/sort.rs | 42 +++++++++++-----------
arrow-select/src/concat.rs | 4 +--
arrow-select/src/interleave.rs | 2 +-
arrow/tests/array_cast.rs | 4 +--
parquet-variant-compute/src/variant_get.rs | 2 +-
parquet-variant-compute/src/variant_to_arrow.rs | 5 ++-
.../arrow/array_reader/byte_array_dictionary.rs | 3 +-
parquet/tests/arrow_reader/statistics.rs | 4 +--
12 files changed, 39 insertions(+), 42 deletions(-)
diff --git a/arrow-arith/src/temporal.rs b/arrow-arith/src/temporal.rs
index faff59bc30..771d0f97b7 100644
--- a/arrow-arith/src/temporal.rs
+++ b/arrow-arith/src/temporal.rs
@@ -189,7 +189,6 @@ pub fn date_part(array: &dyn Array, part: DatePart) ->
Result<ArrayRef, ArrowErr
DataType::Dictionary(_, _) => {
let array = array.as_any_dictionary();
let values = date_part(array.values(), part)?;
- let values = Arc::new(values) as ArrayRef;
let new_array = array.with_values(values);
Ok(new_array)
}
diff --git a/arrow-cast/src/cast/mod.rs b/arrow-cast/src/cast/mod.rs
index ff99e1d6a5..67efb57424 100644
--- a/arrow-cast/src/cast/mod.rs
+++ b/arrow-cast/src/cast/mod.rs
@@ -8963,8 +8963,6 @@ mod tests {
];
for (array, expected) in cases {
- let array = Arc::new(array) as ArrayRef;
-
assert!(
can_cast_types(array.data_type(), expected.data_type()),
"can_cast_types claims we cannot cast {:?} to {:?}",
@@ -13288,8 +13286,7 @@ mod tests {
for values in values_arrays {
let keys =
Int8Array::from_iter([Some(1), Some(0), None, Some(3), None,
Some(1), Some(4)]);
- let string_dict_array =
- DictionaryArray::<Int8Type>::try_new(keys,
Arc::new(values)).unwrap();
+ let string_dict_array = DictionaryArray::<Int8Type>::try_new(keys,
values).unwrap();
let casted = cast(&string_dict_array,
&DataType::BinaryView).unwrap();
assert_eq!(casted.as_ref(), &expected);
@@ -13316,8 +13313,7 @@ mod tests {
for values in values_arrays {
let keys =
Int8Array::from_iter([Some(1), Some(0), None, Some(3), None,
Some(1), Some(4)]);
- let string_dict_array =
- DictionaryArray::<Int8Type>::try_new(keys,
Arc::new(values)).unwrap();
+ let string_dict_array = DictionaryArray::<Int8Type>::try_new(keys,
values).unwrap();
let casted = cast(&string_dict_array,
&DataType::Utf8View).unwrap();
assert_eq!(casted.as_ref(), &expected);
diff --git a/arrow-cast/src/cast/run_array.rs b/arrow-cast/src/cast/run_array.rs
index 9878f09772..dfa97296e8 100644
--- a/arrow-cast/src/cast/run_array.rs
+++ b/arrow-cast/src/cast/run_array.rs
@@ -68,7 +68,7 @@ pub(crate) fn run_end_encoded_cast<K: RunEndIndexType>(
));
}
};
- Ok(Arc::new(new_run_array))
+ Ok(new_run_array)
}
// Expand to logical form
diff --git a/arrow-ipc/src/reader.rs b/arrow-ipc/src/reader.rs
index 4279090dbe..d5cda3e4e5 100644
--- a/arrow-ipc/src/reader.rs
+++ b/arrow-ipc/src/reader.rs
@@ -1954,7 +1954,7 @@ mod tests {
.len(3)
.build()
.unwrap();
- let array9: ArrayRef = Arc::new(StructArray::from(array9));
+ let array9 = StructArray::from(array9);
let array10_input = vec![Some(1_i32), None, None];
let mut array10_builder = PrimitiveRunBuilder::<Int16Type,
Int32Type>::new();
@@ -2995,7 +2995,7 @@ mod tests {
)
};
expect_ipc_validation_error(
- Arc::new(invalid_struct_arr),
+ invalid_struct_arr,
"Invalid argument error: Invalid UTF8 sequence at string index 3
(3..18): invalid utf-8 sequence of 1 bytes from index 11",
);
}
diff --git a/arrow-ord/src/sort.rs b/arrow-ord/src/sort.rs
index 39d56f8fe9..f7f553abb6 100644
--- a/arrow-ord/src/sort.rs
+++ b/arrow-ord/src/sort.rs
@@ -1107,7 +1107,7 @@ mod tests {
) {
let output = create_decimal_array::<T>(data, precision, scale);
let expected = UInt32Array::from(expected_data);
- let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options,
limit).unwrap();
+ let output = sort_to_indices(&output, options, limit).unwrap();
assert_eq!(output, expected)
}
@@ -1119,7 +1119,7 @@ mod tests {
) {
let output = create_decimal256_array(data);
let expected = UInt32Array::from(expected_data);
- let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options,
limit).unwrap();
+ let output = sort_to_indices(&output, options, limit).unwrap();
assert_eq!(output, expected)
}
@@ -1134,8 +1134,8 @@ mod tests {
let output = create_decimal_array::<T>(data, p, s);
let expected = Arc::new(create_decimal_array::<T>(expected_data, p,
s)) as ArrayRef;
let output = match limit {
- Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options,
limit).unwrap(),
- _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
+ Some(_) => sort_limit(&output, options, limit).unwrap(),
+ _ => sort(&output, options).unwrap(),
};
assert_eq!(&output, &expected)
}
@@ -1149,8 +1149,8 @@ mod tests {
let output = create_decimal256_array(data);
let expected = Arc::new(create_decimal256_array(expected_data)) as
ArrayRef;
let output = match limit {
- Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options,
limit).unwrap(),
- _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
+ Some(_) => sort_limit(&output, options, limit).unwrap(),
+ _ => sort(&output, options).unwrap(),
};
assert_eq!(&output, &expected)
}
@@ -1163,7 +1163,7 @@ mod tests {
) {
let output = BooleanArray::from(data);
let expected = UInt32Array::from(expected_data);
- let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options,
limit).unwrap();
+ let output = sort_to_indices(&output, options, limit).unwrap();
assert_eq!(output, expected)
}
@@ -1178,7 +1178,7 @@ mod tests {
{
let output = PrimitiveArray::<T>::from(data);
let expected = UInt32Array::from(expected_data);
- let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options,
limit).unwrap();
+ let output = sort_to_indices(&output, options, limit).unwrap();
assert_eq!(output, expected)
}
@@ -1194,8 +1194,8 @@ mod tests {
let output = PrimitiveArray::<T>::from(data);
let expected = Arc::new(PrimitiveArray::<T>::from(expected_data)) as
ArrayRef;
let output = match limit {
- Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options,
limit).unwrap(),
- _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
+ Some(_) => sort_limit(&output, options, limit).unwrap(),
+ _ => sort(&output, options).unwrap(),
};
assert_eq!(&output, &expected)
}
@@ -1208,7 +1208,7 @@ mod tests {
) {
let output = StringArray::from(data);
let expected = UInt32Array::from(expected_data);
- let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options,
limit).unwrap();
+ let output = sort_to_indices(&output, options, limit).unwrap();
assert_eq!(output, expected)
}
@@ -1222,24 +1222,24 @@ mod tests {
let output = StringArray::from(data.clone());
let expected = Arc::new(StringArray::from(expected_data.clone())) as
ArrayRef;
let output = match limit {
- Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options,
limit).unwrap(),
- _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
+ Some(_) => sort_limit(&output, options, limit).unwrap(),
+ _ => sort(&output, options).unwrap(),
};
assert_eq!(&output, &expected);
let output = LargeStringArray::from(data.clone());
let expected = Arc::new(LargeStringArray::from(expected_data.clone()))
as ArrayRef;
let output = match limit {
- Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options,
limit).unwrap(),
- _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
+ Some(_) => sort_limit(&output, options, limit).unwrap(),
+ _ => sort(&output, options).unwrap(),
};
assert_eq!(&output, &expected);
let output = StringViewArray::from(data);
let expected = Arc::new(StringViewArray::from(expected_data)) as
ArrayRef;
let output = match limit {
- Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options,
limit).unwrap(),
- _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
+ Some(_) => sort_limit(&output, options, limit).unwrap(),
+ _ => sort(&output, options).unwrap(),
};
assert_eq!(&output, &expected);
}
@@ -1258,8 +1258,8 @@ mod tests {
.expect("Unable to get dictionary values");
let sorted = match limit {
- Some(_) => sort_limit(&(Arc::new(array) as ArrayRef), options,
limit).unwrap(),
- _ => sort(&(Arc::new(array) as ArrayRef), options).unwrap(),
+ Some(_) => sort_limit(&array, options, limit).unwrap(),
+ _ => sort(&array, options).unwrap(),
};
let sorted = sorted
.as_any()
@@ -1300,8 +1300,8 @@ mod tests {
let dict = array_values.as_primitive::<T>();
let sorted = match limit {
- Some(_) => sort_limit(&(Arc::new(array) as ArrayRef), options,
limit).unwrap(),
- _ => sort(&(Arc::new(array) as ArrayRef), options).unwrap(),
+ Some(_) => sort_limit(&array, options, limit).unwrap(),
+ _ => sort(&array, options).unwrap(),
};
let sorted = sorted
.as_any()
diff --git a/arrow-select/src/concat.rs b/arrow-select/src/concat.rs
index a6e3083a6e..19eeeacbfb 100644
--- a/arrow-select/src/concat.rs
+++ b/arrow-select/src/concat.rs
@@ -404,13 +404,13 @@ where
macro_rules! dict_helper {
($t:ty, $arrays:expr) => {
- return Ok(Arc::new(concat_dictionaries::<$t>($arrays)?) as _)
+ return concat_dictionaries::<$t>($arrays)
};
}
macro_rules! primitive_concat {
($t:ty, $arrays:expr) => {
- return Ok(Arc::new(concat_primitives::<$t>($arrays)?) as _)
+ return concat_primitives::<$t>($arrays)
};
}
diff --git a/arrow-select/src/interleave.rs b/arrow-select/src/interleave.rs
index d4303e8d85..6598a5eb0d 100644
--- a/arrow-select/src/interleave.rs
+++ b/arrow-select/src/interleave.rs
@@ -37,7 +37,7 @@ macro_rules! primitive_helper {
macro_rules! dict_helper {
($t:ty, $values:expr, $indices:expr) => {
- Ok(Arc::new(interleave_dictionaries::<$t>($values, $indices)?) as _)
+ interleave_dictionaries::<$t>($values, $indices)
};
}
diff --git a/arrow/tests/array_cast.rs b/arrow/tests/array_cast.rs
index 0e3b9c597b..b5a8c43cc4 100644
--- a/arrow/tests/array_cast.rs
+++ b/arrow/tests/array_cast.rs
@@ -592,7 +592,7 @@ fn get_all_types() -> Vec<DataType> {
fn test_timestamp_cast_utf8() {
let array: PrimitiveArray<TimestampMicrosecondType> =
vec![Some(37800000000), None, Some(86339000000)].into();
- let out = cast(&(Arc::new(array) as ArrayRef), &DataType::Utf8).unwrap();
+ let out = cast(&array, &DataType::Utf8).unwrap();
let expected = StringArray::from(vec![
Some("1970-01-01T10:30:00"),
@@ -608,7 +608,7 @@ fn test_timestamp_cast_utf8() {
let array: PrimitiveArray<TimestampMicrosecondType> =
vec![Some(37800000000), None, Some(86339000000)].into();
let array = array.with_timezone("Australia/Sydney".to_string());
- let out = cast(&(Arc::new(array) as ArrayRef), &DataType::Utf8).unwrap();
+ let out = cast(&array, &DataType::Utf8).unwrap();
let expected = StringArray::from(vec![
Some("1970-01-01T20:30:00+10:00"),
diff --git a/parquet-variant-compute/src/variant_get.rs
b/parquet-variant-compute/src/variant_get.rs
index 16e8738e70..35cd5b4e40 100644
--- a/parquet-variant-compute/src/variant_get.rs
+++ b/parquet-variant-compute/src/variant_get.rs
@@ -180,7 +180,7 @@ fn shredded_get_path(
ShreddedPathStep::Missing => {
let num_rows = input.len();
let arr = match as_field.map(|f| f.data_type()) {
- Some(data_type) =>
Arc::new(array::new_null_array(data_type, num_rows)) as _,
+ Some(data_type) => array::new_null_array(data_type,
num_rows),
None => Arc::new(array::NullArray::new(num_rows)) as _,
};
return Ok(arr);
diff --git a/parquet-variant-compute/src/variant_to_arrow.rs
b/parquet-variant-compute/src/variant_to_arrow.rs
index 17a750eed2..106e8915be 100644
--- a/parquet-variant-compute/src/variant_to_arrow.rs
+++ b/parquet-variant-compute/src/variant_to_arrow.rs
@@ -636,7 +636,10 @@ macro_rules! define_variant_to_primitive_builder {
// This is mainly for `FakeNullBuilder`
#[allow(unused_mut)]
fn finish(mut self) -> Result<ArrayRef> {
- Ok(Arc::new(self.builder.finish()))
+ // If the builder produces T: Array, the compiler infers
`<Arc<T> as From<T>>::from`
+ // (which then coerces to ArrayRef). If the builder produces
ArrayRef directly, the
+ // compiler infers `<ArrayRef as From<ArrayRef>>::from`
(no-op, From blanket impl).
+ Ok(Arc::from(self.builder.finish()))
}
}
}
diff --git a/parquet/src/arrow/array_reader/byte_array_dictionary.rs
b/parquet/src/arrow/array_reader/byte_array_dictionary.rs
index 09de37a80e..f7b93264b7 100644
--- a/parquet/src/arrow/array_reader/byte_array_dictionary.rs
+++ b/parquet/src/arrow/array_reader/byte_array_dictionary.rs
@@ -17,7 +17,6 @@
use std::any::Any;
use std::marker::PhantomData;
-use std::sync::Arc;
use arrow_array::{Array, ArrayRef, OffsetSizeTrait, new_empty_array};
use arrow_buffer::ArrowNativeType;
@@ -278,7 +277,7 @@ where
decoder.read(&mut buffer, usize::MAX)?;
let array = buffer.into_array(None, self.value_type.clone());
- self.dict = Some(Arc::new(array));
+ self.dict = Some(array);
Ok(())
}
diff --git a/parquet/tests/arrow_reader/statistics.rs
b/parquet/tests/arrow_reader/statistics.rs
index 07a9bcc578..2f7859d063 100644
--- a/parquet/tests/arrow_reader/statistics.rs
+++ b/parquet/tests/arrow_reader/statistics.rs
@@ -2357,8 +2357,8 @@ async fn test_struct() {
.await;
Test {
reader: &reader,
- expected_min: Arc::new(struct_array(vec![(Some(1), Some(6.0),
Some(12.0))])),
- expected_max: Arc::new(struct_array(vec![(Some(2), Some(8.5),
Some(14.0))])),
+ expected_min: struct_array(vec![(Some(1), Some(6.0), Some(12.0))]),
+ expected_max: struct_array(vec![(Some(2), Some(8.5), Some(14.0))]),
expected_null_counts: UInt64Array::from(vec![0]),
expected_row_counts: Some(UInt64Array::from(vec![3])),
expected_max_value_exact: BooleanArray::from(vec![true, true, true]),
