This is an automated email from the ASF dual-hosted git repository.
tustvold pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/master by this push:
new b79f27b51 Use dyn Array in cast kernels (#3667)
b79f27b51 is described below
commit b79f27b512d46715e9881e34fe4bb525b88fef9d
Author: Raphael Taylor-Davies <[email protected]>
AuthorDate: Mon Feb 6 22:46:23 2023 +0000
Use dyn Array in cast kernels (#3667)
* Use dyn Array in cast kernel
* Fix test
---
arrow-cast/src/cast.rs | 254 +++++++++++++++++++---------------------------
arrow-cast/src/display.rs | 32 +++---
arrow/src/lib.rs | 2 +-
3 files changed, 116 insertions(+), 172 deletions(-)
diff --git a/arrow-cast/src/cast.rs b/arrow-cast/src/cast.rs
index 16a39d773..69e42a548 100644
--- a/arrow-cast/src/cast.rs
+++ b/arrow-cast/src/cast.rs
@@ -320,7 +320,7 @@ pub fn can_cast_types(from_type: &DataType, to_type:
&DataType) -> bool {
/// * To or from `StructArray`
/// * List to primitive
/// * Interval and duration
-pub fn cast(array: &ArrayRef, to_type: &DataType) -> Result<ArrayRef,
ArrowError> {
+pub fn cast(array: &dyn Array, to_type: &DataType) -> Result<ArrayRef,
ArrowError> {
cast_with_options(array, to_type, &DEFAULT_CAST_OPTIONS)
}
@@ -444,7 +444,7 @@ fn cast_reinterpret_arrays<
}
fn cast_decimal_to_integer<D, T>(
- array: &ArrayRef,
+ array: &dyn Array,
base: D::Native,
scale: i8,
cast_options: &CastOptions,
@@ -506,7 +506,7 @@ where
// cast the decimal array to floating-point array
fn cast_decimal_to_float<D: DecimalType, T: ArrowPrimitiveType, F>(
- array: &ArrayRef,
+ array: &dyn Array,
op: F,
) -> Result<ArrayRef, ArrowError>
where
@@ -601,7 +601,7 @@ fn as_time_res_with_timezone<T: ArrowPrimitiveType>(
/// * To or from `StructArray`
/// * List to primitive
pub fn cast_with_options(
- array: &ArrayRef,
+ array: &dyn Array,
to_type: &DataType,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError> {
@@ -610,7 +610,7 @@ pub fn cast_with_options(
// clone array if types are the same
if from_type == to_type {
- return Ok(array.clone());
+ return Ok(make_array(array.data().clone()));
}
match (from_type, to_type) {
(
@@ -683,7 +683,7 @@ pub fn cast_with_options(
"cannot cast list to large-list with different child
data".into(),
))
} else {
- cast_list_container::<i32, i64>(&**array, cast_options)
+ cast_list_container::<i32, i64>(array, cast_options)
}
}
(LargeList(list_from), List(list_to)) => {
@@ -692,7 +692,7 @@ pub fn cast_with_options(
"cannot cast large-list to list with different child
data".into(),
))
} else {
- cast_list_container::<i64, i32>(&**array, cast_options)
+ cast_list_container::<i64, i32>(array, cast_options)
}
}
(List(_) | LargeList(_), _) => match to_type {
@@ -1115,7 +1115,7 @@ pub fn cast_with_options(
))),
},
(Utf8, _) => match to_type {
- LargeUtf8 => cast_byte_container::<Utf8Type, LargeUtf8Type,
str>(&**array),
+ LargeUtf8 => cast_byte_container::<Utf8Type, LargeUtf8Type,
str>(array),
UInt8 => cast_string_to_numeric::<UInt8Type, i32>(array,
cast_options),
UInt16 => cast_string_to_numeric::<UInt16Type, i32>(array,
cast_options),
UInt32 => cast_string_to_numeric::<UInt32Type, i32>(array,
cast_options),
@@ -1126,34 +1126,34 @@ pub fn cast_with_options(
Int64 => cast_string_to_numeric::<Int64Type, i32>(array,
cast_options),
Float32 => cast_string_to_numeric::<Float32Type, i32>(array,
cast_options),
Float64 => cast_string_to_numeric::<Float64Type, i32>(array,
cast_options),
- Date32 => cast_string_to_date32::<i32>(&**array, cast_options),
- Date64 => cast_string_to_date64::<i32>(&**array, cast_options),
+ Date32 => cast_string_to_date32::<i32>(array, cast_options),
+ Date64 => cast_string_to_date64::<i32>(array, cast_options),
Binary =>
Ok(Arc::new(BinaryArray::from(as_string_array(array).clone()))),
LargeBinary => {
let binary = BinaryArray::from(as_string_array(array).clone());
cast_byte_container::<BinaryType, LargeBinaryType,
[u8]>(&binary)
}
Time32(TimeUnit::Second) => {
- cast_string_to_time32second::<i32>(&**array, cast_options)
+ cast_string_to_time32second::<i32>(array, cast_options)
}
Time32(TimeUnit::Millisecond) => {
- cast_string_to_time32millisecond::<i32>(&**array, cast_options)
+ cast_string_to_time32millisecond::<i32>(array, cast_options)
}
Time64(TimeUnit::Microsecond) => {
- cast_string_to_time64microsecond::<i32>(&**array, cast_options)
+ cast_string_to_time64microsecond::<i32>(array, cast_options)
}
Time64(TimeUnit::Nanosecond) => {
- cast_string_to_time64nanosecond::<i32>(&**array, cast_options)
+ cast_string_to_time64nanosecond::<i32>(array, cast_options)
}
Timestamp(TimeUnit::Nanosecond, None) => {
- cast_string_to_timestamp_ns::<i32>(&**array, cast_options)
+ cast_string_to_timestamp_ns::<i32>(array, cast_options)
}
_ => Err(ArrowError::CastError(format!(
"Casting from {from_type:?} to {to_type:?} not supported",
))),
},
(_, Utf8) => match from_type {
- LargeUtf8 => cast_byte_container::<LargeUtf8Type, Utf8Type,
str>(&**array),
+ LargeUtf8 => cast_byte_container::<LargeUtf8Type, Utf8Type,
str>(array),
UInt8 => cast_numeric_to_string::<UInt8Type, i32>(array),
UInt16 => cast_numeric_to_string::<UInt16Type, i32>(array),
UInt32 => cast_numeric_to_string::<UInt32Type, i32>(array),
@@ -1232,8 +1232,8 @@ pub fn cast_with_options(
Int64 => cast_string_to_numeric::<Int64Type, i64>(array,
cast_options),
Float32 => cast_string_to_numeric::<Float32Type, i64>(array,
cast_options),
Float64 => cast_string_to_numeric::<Float64Type, i64>(array,
cast_options),
- Date32 => cast_string_to_date32::<i64>(&**array, cast_options),
- Date64 => cast_string_to_date64::<i64>(&**array, cast_options),
+ Date32 => cast_string_to_date32::<i64>(array, cast_options),
+ Date64 => cast_string_to_date64::<i64>(array, cast_options),
Binary => {
let large_binary =
LargeBinaryArray::from(as_largestring_array(array).clone());
@@ -1243,19 +1243,19 @@ pub fn cast_with_options(
as_largestring_array(array).clone(),
))),
Time32(TimeUnit::Second) => {
- cast_string_to_time32second::<i64>(&**array, cast_options)
+ cast_string_to_time32second::<i64>(array, cast_options)
}
Time32(TimeUnit::Millisecond) => {
- cast_string_to_time32millisecond::<i64>(&**array, cast_options)
+ cast_string_to_time32millisecond::<i64>(array, cast_options)
}
Time64(TimeUnit::Microsecond) => {
- cast_string_to_time64microsecond::<i64>(&**array, cast_options)
+ cast_string_to_time64microsecond::<i64>(array, cast_options)
}
Time64(TimeUnit::Nanosecond) => {
- cast_string_to_time64nanosecond::<i64>(&**array, cast_options)
+ cast_string_to_time64nanosecond::<i64>(array, cast_options)
}
Timestamp(TimeUnit::Nanosecond, None) => {
- cast_string_to_timestamp_ns::<i64>(&**array, cast_options)
+ cast_string_to_timestamp_ns::<i64>(array, cast_options)
}
_ => Err(ArrowError::CastError(format!(
"Casting from {from_type:?} to {to_type:?} not supported",
@@ -1263,14 +1263,14 @@ pub fn cast_with_options(
},
(Binary, _) => match to_type {
LargeBinary => {
- cast_byte_container::<BinaryType, LargeBinaryType,
[u8]>(&**array)
+ cast_byte_container::<BinaryType, LargeBinaryType, [u8]>(array)
}
_ => Err(ArrowError::CastError(format!(
"Casting from {from_type:?} to {to_type:?} not supported",
))),
},
(LargeBinary, _) => match to_type {
- Binary => cast_byte_container::<LargeBinaryType, BinaryType,
[u8]>(&**array),
+ Binary => cast_byte_container::<LargeBinaryType, BinaryType,
[u8]>(array),
_ => Err(ArrowError::CastError(format!(
"Casting from {from_type:?} to {to_type:?} not supported",
))),
@@ -2111,7 +2111,7 @@ where
/// Convert Array into a PrimitiveArray of type, and apply numeric cast
fn cast_numeric_arrays<FROM, TO>(
- from: &ArrayRef,
+ from: &dyn Array,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError>
where
@@ -2235,7 +2235,7 @@ where
/// Cast timestamp types to Utf8/LargeUtf8
fn cast_timestamp_to_string<T, OffsetSize>(
- array: &ArrayRef,
+ array: &dyn Array,
tz: Option<&String>,
) -> Result<ArrayRef, ArrowError>
where
@@ -2271,7 +2271,7 @@ where
/// Cast date32 types to Utf8/LargeUtf8
fn cast_date32_to_string<OffsetSize: OffsetSizeTrait>(
- array: &ArrayRef,
+ array: &dyn Array,
) -> Result<ArrayRef, ArrowError> {
let array = array.as_any().downcast_ref::<Date32Array>().unwrap();
@@ -2290,7 +2290,7 @@ fn cast_date32_to_string<OffsetSize: OffsetSizeTrait>(
/// Cast date64 types to Utf8/LargeUtf8
fn cast_date64_to_string<OffsetSize: OffsetSizeTrait>(
- array: &ArrayRef,
+ array: &dyn Array,
) -> Result<ArrayRef, ArrowError> {
let array = array.as_any().downcast_ref::<Date64Array>().unwrap();
@@ -2309,7 +2309,7 @@ fn cast_date64_to_string<OffsetSize: OffsetSizeTrait>(
/// Cast numeric types to Utf8
fn cast_numeric_to_string<FROM, OffsetSize>(
- array: &ArrayRef,
+ array: &dyn Array,
) -> Result<ArrayRef, ArrowError>
where
FROM: ArrowPrimitiveType,
@@ -2339,7 +2339,7 @@ where
/// Cast numeric types to Utf8
fn cast_string_to_numeric<T, Offset: OffsetSizeTrait>(
- from: &ArrayRef,
+ from: &dyn Array,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError>
where
@@ -2795,7 +2795,7 @@ fn cast_string_to_timestamp_ns<Offset: OffsetSizeTrait>(
/// Casts Utf8 to Boolean
fn cast_utf8_to_boolean<OffsetSize>(
- from: &ArrayRef,
+ from: &dyn Array,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError>
where
@@ -2963,7 +2963,7 @@ where
/// Cast Utf8 to decimal
fn cast_string_to_decimal<T, Offset: OffsetSizeTrait>(
- from: &ArrayRef,
+ from: &dyn Array,
precision: u8,
scale: i8,
cast_options: &CastOptions,
@@ -2998,7 +2998,7 @@ where
/// Cast numeric types to Boolean
///
/// Any zero value returns `false` while non-zero returns `true`
-fn cast_numeric_to_bool<FROM>(from: &ArrayRef) -> Result<ArrayRef, ArrowError>
+fn cast_numeric_to_bool<FROM>(from: &dyn Array) -> Result<ArrayRef, ArrowError>
where
FROM: ArrowPrimitiveType,
{
@@ -3033,7 +3033,7 @@ where
///
/// `false` returns 0 while `true` returns 1
fn cast_bool_to_numeric<TO>(
- from: &ArrayRef,
+ from: &dyn Array,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError>
where
@@ -3076,7 +3076,7 @@ where
///
/// K is the key type
fn dictionary_cast<K: ArrowDictionaryKeyType>(
- array: &ArrayRef,
+ array: &dyn Array,
to_type: &DataType,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError> {
@@ -3153,7 +3153,7 @@ fn dictionary_cast<K: ArrowDictionaryKeyType>(
// Unpack a dictionary where the keys are of type <K> into a flattened array
of type to_type
fn unpack_dictionary<K>(
- array: &ArrayRef,
+ array: &dyn Array,
to_type: &DataType,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError>
@@ -3195,7 +3195,7 @@ where
///
/// K is the key type
fn cast_to_dictionary<K: ArrowDictionaryKeyType>(
- array: &ArrayRef,
+ array: &dyn Array,
dict_value_type: &DataType,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError> {
@@ -3271,7 +3271,7 @@ fn cast_to_dictionary<K: ArrowDictionaryKeyType>(
// Packs the data from the primitive array of type <V> to a
// DictionaryArray with keys of type K and values of value_type V
fn pack_numeric_to_dictionary<K, V>(
- array: &ArrayRef,
+ array: &dyn Array,
dict_value_type: &DataType,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError>
@@ -3303,7 +3303,7 @@ where
// Packs the data as a GenericByteDictionaryBuilder, if possible, with the
// key types of K
fn pack_byte_to_dictionary<K, T>(
- array: &ArrayRef,
+ array: &dyn Array,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError>
where
@@ -3331,7 +3331,7 @@ where
/// Helper function that takes a primitive array and casts to a (generic) list
array.
fn cast_primitive_to_list<OffsetSize: OffsetSizeTrait + NumCast>(
- array: &ArrayRef,
+ array: &dyn Array,
to: &Field,
to_type: &DataType,
cast_options: &CastOptions,
@@ -3371,7 +3371,7 @@ fn cast_primitive_to_list<OffsetSize: OffsetSizeTrait +
NumCast>(
/// Helper function that takes an Generic list container and casts the inner
datatype.
fn cast_list_inner<OffsetSize: OffsetSizeTrait>(
- array: &Arc<dyn Array>,
+ array: &dyn Array,
to: &Field,
to_type: &DataType,
cast_options: &CastOptions,
@@ -3772,8 +3772,7 @@ mod tests {
Some(-3123456),
None,
];
- let input_decimal_array = create_decimal_array(array, 20, 4).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal_array(array, 20, 4).unwrap();
// decimal128 to decimal128
let input_type = DataType::Decimal128(20, 4);
let output_type = DataType::Decimal128(20, 3);
@@ -3816,8 +3815,7 @@ mod tests {
Some(i256::from_i128(-3123456)),
None,
];
- let input_decimal_array = create_decimal256_array(array, 20,
4).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal256_array(array, 20, 4).unwrap();
// decimal256 to decimal256
let input_type = DataType::Decimal256(20, 4);
@@ -3859,8 +3857,7 @@ mod tests {
let output_type = DataType::Decimal128(20, 4);
assert!(can_cast_types(&input_type, &output_type));
let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
- let input_decimal_array = create_decimal_array(array, 20, 3).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal_array(array, 20, 3).unwrap();
generate_cast_test_case!(
&array,
Decimal128Array,
@@ -3874,8 +3871,7 @@ mod tests {
);
// negative test
let array = vec![Some(123456), None];
- let input_decimal_array = create_decimal_array(array, 10, 0).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal_array(array, 10, 0).unwrap();
let result = cast(&array, &DataType::Decimal128(2, 2));
assert!(result.is_ok());
let array = result.unwrap();
@@ -3892,8 +3888,7 @@ mod tests {
assert!(can_cast_types(&input_type, &output_type));
let array = vec![Some(i128::MAX)];
- let input_decimal_array = create_decimal_array(array, 38, 3).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal_array(array, 38, 3).unwrap();
let result =
cast_with_options(&array, &output_type, &CastOptions { safe: false
});
assert_eq!("Cast error: Cannot cast to Decimal128(38, 38). Overflowing
on 170141183460469231731687303715884105727",
@@ -3907,8 +3902,7 @@ mod tests {
assert!(can_cast_types(&input_type, &output_type));
let array = vec![Some(i128::MAX)];
- let input_decimal_array = create_decimal_array(array, 38, 3).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal_array(array, 38, 3).unwrap();
let result =
cast_with_options(&array, &output_type, &CastOptions { safe: false
});
assert_eq!("Cast error: Cannot cast to Decimal256(76, 76). Overflowing
on 170141183460469231731687303715884105727",
@@ -3921,8 +3915,7 @@ mod tests {
let output_type = DataType::Decimal256(20, 4);
assert!(can_cast_types(&input_type, &output_type));
let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
- let input_decimal_array = create_decimal_array(array, 20, 3).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal_array(array, 20, 3).unwrap();
generate_cast_test_case!(
&array,
Decimal256Array,
@@ -3942,8 +3935,7 @@ mod tests {
let output_type = DataType::Decimal128(38, 7);
assert!(can_cast_types(&input_type, &output_type));
let array = vec![Some(i256::from_i128(i128::MAX))];
- let input_decimal_array = create_decimal256_array(array, 76,
5).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal256_array(array, 76, 5).unwrap();
let result =
cast_with_options(&array, &output_type, &CastOptions { safe: false
});
assert_eq!("Cast error: Cannot cast to Decimal128(38, 7). Overflowing
on 170141183460469231731687303715884105727",
@@ -3956,8 +3948,7 @@ mod tests {
let output_type = DataType::Decimal256(76, 55);
assert!(can_cast_types(&input_type, &output_type));
let array = vec![Some(i256::from_i128(i128::MAX))];
- let input_decimal_array = create_decimal256_array(array, 76,
5).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal256_array(array, 76, 5).unwrap();
let result =
cast_with_options(&array, &output_type, &CastOptions { safe: false
});
assert_eq!("Cast error: Cannot cast to Decimal256(76, 55). Overflowing
on 170141183460469231731687303715884105727",
@@ -3975,8 +3966,7 @@ mod tests {
Some(i256::from_i128(3123456)),
None,
];
- let input_decimal_array = create_decimal256_array(array, 20,
3).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal256_array(array, 20, 3).unwrap();
generate_cast_test_case!(
&array,
Decimal128Array,
@@ -4001,8 +3991,7 @@ mod tests {
Some(i256::from_i128(3123456)),
None,
];
- let input_decimal_array = create_decimal256_array(array, 20,
3).unwrap();
- let array = Arc::new(input_decimal_array) as ArrayRef;
+ let array = create_decimal256_array(array, 20, 3).unwrap();
generate_cast_test_case!(
&array,
Decimal256Array,
@@ -4020,8 +4009,7 @@ mod tests {
fn test_cast_decimal_to_numeric() {
let value_array: Vec<Option<i128>> =
vec![Some(125), Some(225), Some(325), None, Some(525)];
- let decimal_array = create_decimal_array(value_array, 38, 2).unwrap();
- let array = Arc::new(decimal_array) as ArrayRef;
+ let array = create_decimal_array(value_array, 38, 2).unwrap();
// u8
generate_cast_test_case!(
&array,
@@ -4107,8 +4095,7 @@ mod tests {
// overflow test: out of range of max u8
let value_array: Vec<Option<i128>> = vec![Some(51300)];
- let decimal_array = create_decimal_array(value_array, 38, 2).unwrap();
- let array = Arc::new(decimal_array) as ArrayRef;
+ let array = create_decimal_array(value_array, 38, 2).unwrap();
let casted_array =
cast_with_options(&array, &DataType::UInt8, &CastOptions { safe:
false });
assert_eq!(
@@ -4123,8 +4110,7 @@ mod tests {
// overflow test: out of range of max i8
let value_array: Vec<Option<i128>> = vec![Some(24400)];
- let decimal_array = create_decimal_array(value_array, 38, 2).unwrap();
- let array = Arc::new(decimal_array) as ArrayRef;
+ let array = create_decimal_array(value_array, 38, 2).unwrap();
let casted_array =
cast_with_options(&array, &DataType::Int8, &CastOptions { safe:
false });
assert_eq!(
@@ -4149,8 +4135,7 @@ mod tests {
Some(112345678),
Some(112345679),
];
- let decimal_array = create_decimal_array(value_array, 38, 2).unwrap();
- let array = Arc::new(decimal_array) as ArrayRef;
+ let array = create_decimal_array(value_array, 38, 2).unwrap();
generate_cast_test_case!(
&array,
Float32Array,
@@ -4177,8 +4162,7 @@ mod tests {
Some(112345678901234568),
Some(112345678901234560),
];
- let decimal_array = create_decimal_array(value_array, 38, 2).unwrap();
- let array = Arc::new(decimal_array) as ArrayRef;
+ let array = create_decimal_array(value_array, 38, 2).unwrap();
generate_cast_test_case!(
&array,
Float64Array,
@@ -4204,8 +4188,7 @@ mod tests {
None,
Some(i256::from_i128(525)),
];
- let decimal_array = create_decimal256_array(value_array, 38,
2).unwrap();
- let array = Arc::new(decimal_array) as ArrayRef;
+ let array = create_decimal256_array(value_array, 38, 2).unwrap();
// u8
generate_cast_test_case!(
&array,
@@ -4291,8 +4274,7 @@ mod tests {
// overflow test: out of range of max i8
let value_array: Vec<Option<i256>> =
vec![Some(i256::from_i128(24400))];
- let decimal_array = create_decimal256_array(value_array, 38,
2).unwrap();
- let array = Arc::new(decimal_array) as ArrayRef;
+ let array = create_decimal256_array(value_array, 38, 2).unwrap();
let casted_array =
cast_with_options(&array, &DataType::Int8, &CastOptions { safe:
false });
assert_eq!(
@@ -4317,8 +4299,7 @@ mod tests {
Some(i256::from_i128(112345678)),
Some(i256::from_i128(112345679)),
];
- let decimal_array = create_decimal256_array(value_array, 76,
2).unwrap();
- let array = Arc::new(decimal_array) as ArrayRef;
+ let array = create_decimal256_array(value_array, 76, 2).unwrap();
generate_cast_test_case!(
&array,
Float32Array,
@@ -4345,8 +4326,7 @@ mod tests {
Some(i256::from_i128(112345678901234568)),
Some(i256::from_i128(112345678901234560)),
];
- let decimal_array = create_decimal256_array(value_array, 76,
2).unwrap();
- let array = Arc::new(decimal_array) as ArrayRef;
+ let array = create_decimal256_array(value_array, 76, 2).unwrap();
generate_cast_test_case!(
&array,
Float64Array,
@@ -4462,7 +4442,6 @@ mod tests {
// test u8 to decimal type with overflow the result type
// the 100 will be converted to 1000_i128, but it is out of range for
max value in the precision 3.
let array = UInt8Array::from(vec![1, 2, 3, 4, 100]);
- let array = Arc::new(array) as ArrayRef;
let casted_array = cast(&array, &DataType::Decimal128(3, 1));
assert!(casted_array.is_ok());
let array = casted_array.unwrap();
@@ -4473,7 +4452,6 @@ mod tests {
// test i8 to decimal type with overflow the result type
// the 100 will be converted to 1000_i128, but it is out of range for
max value in the precision 3.
let array = Int8Array::from(vec![1, 2, 3, 4, 100]);
- let array = Arc::new(array) as ArrayRef;
let casted_array = cast(&array, &DataType::Decimal128(3, 1));
assert!(casted_array.is_ok());
let array = casted_array.unwrap();
@@ -4516,7 +4494,6 @@ mod tests {
Some(1.123_456_489_012_345_6), // round down
Some(1.123_456_789_012_345_6), // round up
]);
- let array = Arc::new(array) as ArrayRef;
generate_cast_test_case!(
&array,
Decimal128Array,
@@ -4650,7 +4627,6 @@ mod tests {
Some(1.123_456_4), // round down
Some(1.123_456_7), // round up
]);
- let array = Arc::new(array) as ArrayRef;
generate_cast_test_case!(
&array,
Decimal256Array,
@@ -4676,7 +4652,6 @@ mod tests {
Some(1.123_456_489_012_345_6), // round down
Some(1.123_456_789_012_345_6), // round up
]);
- let array = Arc::new(array) as ArrayRef;
generate_cast_test_case!(
&array,
Decimal256Array,
@@ -4696,8 +4671,7 @@ mod tests {
#[test]
fn test_cast_i32_to_f64() {
- let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
let b = cast(&array, &DataType::Float64).unwrap();
let c = b.as_any().downcast_ref::<Float64Array>().unwrap();
assert_eq!(5.0, c.value(0));
@@ -4709,8 +4683,7 @@ mod tests {
#[test]
fn test_cast_i32_to_u8() {
- let a = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
let b = cast(&array, &DataType::UInt8).unwrap();
let c = b.as_any().downcast_ref::<UInt8Array>().unwrap();
assert!(!c.is_valid(0));
@@ -4724,8 +4697,7 @@ mod tests {
#[test]
#[should_panic(expected = "Can't cast value -5 to type UInt8")]
fn test_cast_int32_to_u8_with_error() {
- let a = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
// overflow with the error
let cast_option = CastOptions { safe: false };
let result = cast_with_options(&array, &DataType::UInt8, &cast_option);
@@ -4735,8 +4707,7 @@ mod tests {
#[test]
fn test_cast_i32_to_u8_sliced() {
- let a = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
assert_eq!(0, array.offset());
let array = array.slice(2, 3);
assert_eq!(2, array.offset());
@@ -4752,8 +4723,7 @@ mod tests {
#[test]
fn test_cast_i32_to_i32() {
- let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
let b = cast(&array, &DataType::Int32).unwrap();
let c = b.as_any().downcast_ref::<Int32Array>().unwrap();
assert_eq!(5, c.value(0));
@@ -4765,8 +4735,7 @@ mod tests {
#[test]
fn test_cast_i32_to_list_i32() {
- let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
let b = cast(
&array,
&DataType::List(Box::new(Field::new("item", DataType::Int32,
true))),
@@ -4790,8 +4759,7 @@ mod tests {
#[test]
fn test_cast_i32_to_list_i32_nullable() {
- let a = Int32Array::from(vec![Some(5), None, Some(7), Some(8),
Some(9)]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Int32Array::from(vec![Some(5), None, Some(7), Some(8),
Some(9)]);
let b = cast(
&array,
&DataType::List(Box::new(Field::new("item", DataType::Int32,
true))),
@@ -4818,8 +4786,8 @@ mod tests {
#[test]
fn test_cast_i32_to_list_f64_nullable_sliced() {
- let a = Int32Array::from(vec![Some(5), None, Some(7), Some(8), None,
Some(10)]);
- let array = Arc::new(a) as ArrayRef;
+ let array =
+ Int32Array::from(vec![Some(5), None, Some(7), Some(8), None,
Some(10)]);
let array = array.slice(2, 4);
let b = cast(
&array,
@@ -4844,8 +4812,7 @@ mod tests {
#[test]
fn test_cast_utf8_to_i32() {
- let a = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
- let array = Arc::new(a) as ArrayRef;
+ let array = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
let b = cast(&array, &DataType::Int32).unwrap();
let c = b.as_any().downcast_ref::<Int32Array>().unwrap();
assert_eq!(5, c.value(0));
@@ -4857,8 +4824,7 @@ mod tests {
#[test]
fn test_cast_with_options_utf8_to_i32() {
- let a = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
- let array = Arc::new(a) as ArrayRef;
+ let array = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
let result =
cast_with_options(&array, &DataType::Int32, &CastOptions { safe:
false });
match result {
@@ -4876,9 +4842,7 @@ mod tests {
#[test]
fn test_cast_utf8_to_bool() {
- let strings = Arc::new(StringArray::from(vec![
- "true", "false", "invalid", " Y ", "",
- ])) as ArrayRef;
+ let strings = StringArray::from(vec!["true", "false", "invalid", " Y
", ""]);
let casted = cast(&strings, &DataType::Boolean).unwrap();
let expected =
BooleanArray::from(vec![Some(true), Some(false), None, Some(true),
None]);
@@ -4887,9 +4851,7 @@ mod tests {
#[test]
fn test_cast_with_options_utf8_to_bool() {
- let strings = Arc::new(StringArray::from(vec![
- "true", "false", "invalid", " Y ", "",
- ])) as ArrayRef;
+ let strings = StringArray::from(vec!["true", "false", "invalid", " Y
", ""]);
let casted =
cast_with_options(&strings, &DataType::Boolean, &CastOptions {
safe: false });
match casted {
@@ -4904,8 +4866,7 @@ mod tests {
#[test]
fn test_cast_bool_to_i32() {
- let a = BooleanArray::from(vec![Some(true), Some(false), None]);
- let array = Arc::new(a) as ArrayRef;
+ let array = BooleanArray::from(vec![Some(true), Some(false), None]);
let b = cast(&array, &DataType::Int32).unwrap();
let c = b.as_any().downcast_ref::<Int32Array>().unwrap();
assert_eq!(1, c.value(0));
@@ -4915,8 +4876,7 @@ mod tests {
#[test]
fn test_cast_bool_to_f64() {
- let a = BooleanArray::from(vec![Some(true), Some(false), None]);
- let array = Arc::new(a) as ArrayRef;
+ let array = BooleanArray::from(vec![Some(true), Some(false), None]);
let b = cast(&array, &DataType::Float64).unwrap();
let c = b.as_any().downcast_ref::<Float64Array>().unwrap();
assert_eq!(1.0, c.value(0));
@@ -4929,8 +4889,7 @@ mod tests {
expected = "Casting from Int32 to Timestamp(Microsecond, None) not
supported"
)]
fn test_cast_int32_to_timestamp() {
- let a = Int32Array::from(vec![Some(2), Some(10), None]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Int32Array::from(vec![Some(2), Some(10), None]);
cast(&array, &DataType::Timestamp(TimeUnit::Microsecond,
None)).unwrap();
}
@@ -4952,7 +4911,7 @@ mod tests {
.add_child_data(value_data)
.build()
.unwrap();
- let list_array = Arc::new(ListArray::from(list_data)) as ArrayRef;
+ let list_array = ListArray::from(list_data);
let cast_array = cast(
&list_array,
@@ -5279,8 +5238,7 @@ mod tests {
#[test]
fn test_cast_date32_to_int32() {
- let a = Date32Array::from(vec![10000, 17890]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Date32Array::from(vec![10000, 17890]);
let b = cast(&array, &DataType::Int32).unwrap();
let c = b.as_any().downcast_ref::<Int32Array>().unwrap();
assert_eq!(10000, c.value(0));
@@ -5289,8 +5247,7 @@ mod tests {
#[test]
fn test_cast_int32_to_date32() {
- let a = Int32Array::from(vec![10000, 17890]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Int32Array::from(vec![10000, 17890]);
let b = cast(&array, &DataType::Date32).unwrap();
let c = b.as_any().downcast_ref::<Date32Array>().unwrap();
assert_eq!(10000, c.value(0));
@@ -5299,13 +5256,12 @@ mod tests {
#[test]
fn test_cast_timestamp_to_date32() {
- let a = TimestampMillisecondArray::from(vec![
+ let array = TimestampMillisecondArray::from(vec![
Some(864000000005),
Some(1545696000001),
None,
])
.with_timezone("UTC".to_string());
- let array = Arc::new(a) as ArrayRef;
let b = cast(&array, &DataType::Date32).unwrap();
let c = b.as_any().downcast_ref::<Date32Array>().unwrap();
assert_eq!(10000, c.value(0));
@@ -5315,12 +5271,11 @@ mod tests {
#[test]
fn test_cast_timestamp_to_date64() {
- let a = TimestampMillisecondArray::from(vec![
+ let array = TimestampMillisecondArray::from(vec![
Some(864000000005),
Some(1545696000001),
None,
]);
- let array = Arc::new(a) as ArrayRef;
let b = cast(&array, &DataType::Date64).unwrap();
let c = b.as_any().downcast_ref::<Date64Array>().unwrap();
assert_eq!(864000000005, c.value(0));
@@ -5331,9 +5286,8 @@ mod tests {
#[test]
fn test_cast_timestamp_to_time64() {
// test timestamp secs
- let a = TimestampSecondArray::from(vec![Some(86405), Some(1), None])
+ let array = TimestampSecondArray::from(vec![Some(86405), Some(1),
None])
.with_timezone("+01:00".to_string());
- let array = Arc::new(a) as ArrayRef;
let b = cast(&array,
&DataType::Time64(TimeUnit::Microsecond)).unwrap();
let c = b.as_any().downcast_ref::<Time64MicrosecondArray>().unwrap();
assert_eq!(3605000000, c.value(0));
@@ -5484,8 +5438,8 @@ mod tests {
#[test]
fn test_cast_date64_to_timestamp() {
- let a = Date64Array::from(vec![Some(864000000005),
Some(1545696000001), None]);
- let array = Arc::new(a) as ArrayRef;
+ let array =
+ Date64Array::from(vec![Some(864000000005), Some(1545696000001),
None]);
let b = cast(&array, &DataType::Timestamp(TimeUnit::Second,
None)).unwrap();
let c = b.as_any().downcast_ref::<TimestampSecondArray>().unwrap();
assert_eq!(864000000, c.value(0));
@@ -5495,8 +5449,8 @@ mod tests {
#[test]
fn test_cast_date64_to_timestamp_ms() {
- let a = Date64Array::from(vec![Some(864000000005),
Some(1545696000001), None]);
- let array = Arc::new(a) as ArrayRef;
+ let array =
+ Date64Array::from(vec![Some(864000000005), Some(1545696000001),
None]);
let b = cast(&array, &DataType::Timestamp(TimeUnit::Millisecond,
None)).unwrap();
let c = b
.as_any()
@@ -5509,8 +5463,8 @@ mod tests {
#[test]
fn test_cast_date64_to_timestamp_us() {
- let a = Date64Array::from(vec![Some(864000000005),
Some(1545696000001), None]);
- let array = Arc::new(a) as ArrayRef;
+ let array =
+ Date64Array::from(vec![Some(864000000005), Some(1545696000001),
None]);
let b = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond,
None)).unwrap();
let c = b
.as_any()
@@ -5523,8 +5477,8 @@ mod tests {
#[test]
fn test_cast_date64_to_timestamp_ns() {
- let a = Date64Array::from(vec![Some(864000000005),
Some(1545696000001), None]);
- let array = Arc::new(a) as ArrayRef;
+ let array =
+ Date64Array::from(vec![Some(864000000005), Some(1545696000001),
None]);
let b = cast(&array, &DataType::Timestamp(TimeUnit::Nanosecond,
None)).unwrap();
let c = b
.as_any()
@@ -5537,13 +5491,12 @@ mod tests {
#[test]
fn test_cast_timestamp_to_i64() {
- let a = TimestampMillisecondArray::from(vec![
+ let array = TimestampMillisecondArray::from(vec![
Some(864000000005),
Some(1545696000001),
None,
])
.with_timezone("UTC".to_string());
- let array = Arc::new(a) as ArrayRef;
let b = cast(&array, &DataType::Int64).unwrap();
let c = b.as_any().downcast_ref::<Int64Array>().unwrap();
assert_eq!(&DataType::Int64, c.data_type());
@@ -5554,8 +5507,7 @@ mod tests {
#[test]
fn test_cast_date32_to_string() {
- let a = Date32Array::from(vec![10000, 17890]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Date32Array::from(vec![10000, 17890]);
let b = cast(&array, &DataType::Utf8).unwrap();
let c = b.as_any().downcast_ref::<StringArray>().unwrap();
assert_eq!(&DataType::Utf8, c.data_type());
@@ -5565,8 +5517,7 @@ mod tests {
#[test]
fn test_cast_date64_to_string() {
- let a = Date64Array::from(vec![10000 * 86400000, 17890 * 86400000]);
- let array = Arc::new(a) as ArrayRef;
+ let array = Date64Array::from(vec![10000 * 86400000, 17890 *
86400000]);
let b = cast(&array, &DataType::Utf8).unwrap();
let c = b.as_any().downcast_ref::<StringArray>().unwrap();
assert_eq!(&DataType::Utf8, c.data_type());
@@ -5576,12 +5527,11 @@ mod tests {
#[test]
fn test_cast_between_timestamps() {
- let a = TimestampMillisecondArray::from(vec![
+ let array = TimestampMillisecondArray::from(vec![
Some(864000003005),
Some(1545696002001),
None,
]);
- let array = Arc::new(a) as ArrayRef;
let b = cast(&array, &DataType::Timestamp(TimeUnit::Second,
None)).unwrap();
let c = b.as_any().downcast_ref::<TimestampSecondArray>().unwrap();
assert_eq!(864000003, c.value(0));
@@ -5629,7 +5579,7 @@ mod tests {
#[test]
fn test_cast_to_strings() {
- let a = Arc::new(Int32Array::from(vec![1, 2, 3])) as ArrayRef;
+ let a = Int32Array::from(vec![1, 2, 3]);
let out = cast(&a, &DataType::Utf8).unwrap();
let out = out
.as_any()
@@ -5654,7 +5604,7 @@ mod tests {
vec![Some("foo"), Some("bar"), Some("ham")],
vec![Some("foo"), None, Some("bar")],
] {
- let a = Arc::new(LargeStringArray::from(data.clone())) as ArrayRef;
+ let a = LargeStringArray::from(data.clone());
let to = cast(&a, &DataType::Utf8).unwrap();
let expect = a
.as_any()
@@ -5670,7 +5620,7 @@ mod tests {
.collect::<Vec<_>>();
assert_eq!(expect, out);
- let a = Arc::new(StringArray::from(data)) as ArrayRef;
+ let a = StringArray::from(data);
let to = cast(&a, &DataType::LargeUtf8).unwrap();
let expect = a
.as_any()
@@ -6601,7 +6551,7 @@ mod tests {
#[test]
fn test_cast_from_int8() {
let i8_values: Vec<i8> = vec![i8::MIN, 0, i8::MAX];
- let i8_array: ArrayRef = Arc::new(Int8Array::from(i8_values));
+ let i8_array = Int8Array::from(i8_values);
let f64_expected = vec!["-128.0", "0.0", "127.0"];
assert_eq!(
@@ -6665,7 +6615,7 @@ mod tests {
}
/// Convert `array` into a vector of strings by casting to data type dt
- fn get_cast_values<T>(array: &ArrayRef, dt: &DataType) -> Vec<String>
+ fn get_cast_values<T>(array: &dyn Array, dt: &DataType) -> Vec<String>
where
T: ArrowPrimitiveType,
{
@@ -6782,7 +6732,7 @@ mod tests {
let val = format!("val{i}");
builder.append(&val).unwrap();
}
- let array: ArrayRef = Arc::new(builder.finish());
+ let array = builder.finish();
let cast_type = Dictionary(Box::new(Int8), Box::new(Utf8));
let res = cast(&array, &cast_type);
diff --git a/arrow-cast/src/display.rs b/arrow-cast/src/display.rs
index 721432112..bd4829898 100644
--- a/arrow-cast/src/display.rs
+++ b/arrow-cast/src/display.rs
@@ -20,7 +20,6 @@
//! record batch pretty printing.
use std::fmt::Write;
-use std::sync::Arc;
use arrow_array::timezone::Tz;
use arrow_array::types::*;
@@ -387,7 +386,7 @@ macro_rules! make_string_from_duration {
#[inline(always)]
pub fn make_string_from_decimal(
- column: &Arc<dyn Array>,
+ column: &dyn Array,
row: usize,
) -> Result<String, ArrowError> {
let array = column.as_any().downcast_ref::<Decimal128Array>().unwrap();
@@ -398,7 +397,7 @@ pub fn make_string_from_decimal(
fn append_struct_field_string(
target: &mut String,
name: &str,
- field_col: &Arc<dyn Array>,
+ field_col: &dyn Array,
row: usize,
) -> Result<(), ArrowError> {
target.push('"');
@@ -425,7 +424,7 @@ fn append_struct_field_string(
fn append_map_field_string(
target: &mut String,
- field_col: &Arc<dyn Array>,
+ field_col: &dyn Array,
row: usize,
) -> Result<(), ArrowError> {
if field_col.is_null(row) {
@@ -451,7 +450,7 @@ fn append_map_field_string(
/// Note this function is quite inefficient and is unlikely to be
/// suitable for converting large arrays or record batches.
fn array_value_to_string_internal(
- column: &ArrayRef,
+ column: &dyn Array,
col_idx: usize,
row_idx: usize,
format: Option<&str>,
@@ -722,7 +721,7 @@ fn array_value_to_string_internal(
}
pub fn temporal_array_value_to_string(
- column: &ArrayRef,
+ column: &dyn Array,
col_idx: usize,
row_idx: usize,
format: Option<&str>,
@@ -731,7 +730,7 @@ pub fn temporal_array_value_to_string(
}
pub fn array_value_to_string(
- column: &ArrayRef,
+ column: &dyn Array,
row_idx: usize,
) -> Result<String, ArrowError> {
array_value_to_string_internal(column, 0, row_idx, None)
@@ -739,7 +738,7 @@ pub fn array_value_to_string(
/// Converts the value of the union array at `row` to a String
fn union_to_string(
- column: &ArrayRef,
+ column: &dyn Array,
row: usize,
fields: &[Field],
type_ids: &[i8],
@@ -773,7 +772,7 @@ fn union_to_string(
}
/// Converts the value of the dictionary array at `row` to a String
fn dict_array_value_to_string<K: ArrowPrimitiveType>(
- colum: &ArrayRef,
+ colum: &dyn Array,
row: usize,
) -> Result<String, ArrowError> {
let dict_array =
colum.as_any().downcast_ref::<DictionaryArray<K>>().unwrap();
@@ -824,35 +823,30 @@ mod tests {
&entry_offsets,
)
.unwrap();
- let param = Arc::new(map_array) as ArrayRef;
assert_eq!(
"{\"d\": 30, \"e\": 40, \"f\": 50}",
- array_value_to_string(¶m, 1).unwrap()
+ array_value_to_string(&map_array, 1).unwrap()
);
}
#[test]
fn test_array_value_to_string_duration() {
- let ns_array =
- Arc::new(DurationNanosecondArray::from(vec![Some(1), None])) as
ArrayRef;
+ let ns_array = DurationNanosecondArray::from(vec![Some(1), None]);
assert_eq!(
array_value_to_string(&ns_array, 0).unwrap(),
"PT0.000000001S"
);
assert_eq!(array_value_to_string(&ns_array, 1).unwrap(), "");
- let us_array =
- Arc::new(DurationMicrosecondArray::from(vec![Some(1), None])) as
ArrayRef;
+ let us_array = DurationMicrosecondArray::from(vec![Some(1), None]);
assert_eq!(array_value_to_string(&us_array, 0).unwrap(),
"PT0.000001S");
assert_eq!(array_value_to_string(&us_array, 1).unwrap(), "");
- let ms_array =
- Arc::new(DurationMillisecondArray::from(vec![Some(1), None])) as
ArrayRef;
+ let ms_array = DurationMillisecondArray::from(vec![Some(1), None]);
assert_eq!(array_value_to_string(&ms_array, 0).unwrap(), "PT0.001S");
assert_eq!(array_value_to_string(&ms_array, 1).unwrap(), "");
- let s_array =
- Arc::new(DurationSecondArray::from(vec![Some(1), None])) as
ArrayRef;
+ let s_array = DurationSecondArray::from(vec![Some(1), None]);
assert_eq!(array_value_to_string(&s_array, 0).unwrap(), "PT1S");
assert_eq!(array_value_to_string(&s_array, 1).unwrap(), "");
}
diff --git a/arrow/src/lib.rs b/arrow/src/lib.rs
index 64e5d6a2c..f7ce24a97 100644
--- a/arrow/src/lib.rs
+++ b/arrow/src/lib.rs
@@ -186,7 +186,7 @@
//! where
//! I: IntoIterator<Item=&'a str>,
//! {
-//! let array =
Arc::new(StringArray::from_iter(iter.into_iter().map(Some))) as _;
+//! let array = StringArray::from_iter(iter.into_iter().map(Some));
//! arrow::compute::cast(&array, to_data_type)
//! }
//!
