This is an automated email from the ASF dual-hosted git repository.
alamb pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datafusion.git
The following commit(s) were added to refs/heads/main by this push:
new 7089c6492a Minor: Unify `downcast_arg` method (#13865)
7089c6492a is described below
commit 7089c6492ade0e5d1fbeaa4f6176435a50ed3956
Author: Oleks V <[email protected]>
AuthorDate: Fri Dec 20 18:38:11 2024 -0800
Minor: Unify `downcast_arg` method (#13865)
---
datafusion/functions-nested/src/distance.rs | 7 +++----
datafusion/functions-nested/src/length.rs | 7 +++----
datafusion/functions-nested/src/string.rs | 9 ++++++---
datafusion/functions-nested/src/utils.rs | 19 ++++---------------
datafusion/functions/src/macros.rs | 21 +++++++++++++++++----
datafusion/functions/src/math/abs.rs | 8 ++++----
datafusion/functions/src/math/factorial.rs | 6 ++++--
datafusion/functions/src/math/gcd.rs | 8 +++++---
datafusion/functions/src/math/lcm.rs | 8 +++++---
datafusion/functions/src/math/power.rs | 8 ++++----
10 files changed, 55 insertions(+), 46 deletions(-)
diff --git a/datafusion/functions-nested/src/distance.rs
b/datafusion/functions-nested/src/distance.rs
index 381ddeb59a..704e840da3 100644
--- a/datafusion/functions-nested/src/distance.rs
+++ b/datafusion/functions-nested/src/distance.rs
@@ -17,24 +17,23 @@
//! [ScalarUDFImpl] definitions for array_distance function.
-use crate::utils::{downcast_arg, make_scalar_function};
+use crate::utils::make_scalar_function;
use arrow_array::{
Array, ArrayRef, Float64Array, LargeListArray, ListArray, OffsetSizeTrait,
};
use arrow_schema::DataType;
use arrow_schema::DataType::{FixedSizeList, Float64, LargeList, List};
-use core::any::type_name;
use datafusion_common::cast::{
as_float32_array, as_float64_array, as_generic_list_array, as_int32_array,
as_int64_array,
};
use datafusion_common::utils::coerced_fixed_size_list_to_list;
-use datafusion_common::DataFusionError;
-use datafusion_common::{exec_err, Result};
+use datafusion_common::{exec_err, internal_datafusion_err, Result};
use datafusion_expr::scalar_doc_sections::DOC_SECTION_ARRAY;
use datafusion_expr::{
ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,
};
+use datafusion_functions::{downcast_arg, downcast_named_arg};
use std::any::Any;
use std::sync::{Arc, OnceLock};
diff --git a/datafusion/functions-nested/src/length.rs
b/datafusion/functions-nested/src/length.rs
index 3f92cb3ebb..2f03842cbe 100644
--- a/datafusion/functions-nested/src/length.rs
+++ b/datafusion/functions-nested/src/length.rs
@@ -17,20 +17,19 @@
//! [`ScalarUDFImpl`] definitions for array_length function.
-use crate::utils::{downcast_arg, make_scalar_function};
+use crate::utils::make_scalar_function;
use arrow_array::{
Array, ArrayRef, Int64Array, LargeListArray, ListArray, OffsetSizeTrait,
UInt64Array,
};
use arrow_schema::DataType;
use arrow_schema::DataType::{FixedSizeList, LargeList, List, UInt64};
-use core::any::type_name;
use datafusion_common::cast::{as_generic_list_array, as_int64_array};
-use datafusion_common::DataFusionError;
-use datafusion_common::{exec_err, plan_err, Result};
+use datafusion_common::{exec_err, internal_datafusion_err, plan_err, Result};
use datafusion_expr::scalar_doc_sections::DOC_SECTION_ARRAY;
use datafusion_expr::{
ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,
};
+use datafusion_functions::{downcast_arg, downcast_named_arg};
use std::any::Any;
use std::sync::{Arc, OnceLock};
diff --git a/datafusion/functions-nested/src/string.rs
b/datafusion/functions-nested/src/string.rs
index 143a3d06a3..9288b374da 100644
--- a/datafusion/functions-nested/src/string.rs
+++ b/datafusion/functions-nested/src/string.rs
@@ -26,11 +26,13 @@ use arrow::array::{
use arrow::datatypes::{DataType, Field};
use datafusion_expr::TypeSignature;
-use datafusion_common::{not_impl_err, plan_err, DataFusionError, Result};
+use datafusion_common::{
+ internal_datafusion_err, not_impl_err, plan_err, DataFusionError, Result,
+};
-use std::any::{type_name, Any};
+use std::any::Any;
-use crate::utils::{downcast_arg, make_scalar_function};
+use crate::utils::make_scalar_function;
use arrow::compute::cast;
use arrow_array::builder::{ArrayBuilder, LargeStringBuilder,
StringViewBuilder};
use arrow_array::cast::AsArray;
@@ -45,6 +47,7 @@ use datafusion_expr::{
ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,
};
use datafusion_functions::strings::StringArrayType;
+use datafusion_functions::{downcast_arg, downcast_named_arg};
use std::sync::{Arc, OnceLock};
macro_rules! call_array_function {
diff --git a/datafusion/functions-nested/src/utils.rs
b/datafusion/functions-nested/src/utils.rs
index 4b7b5ebd8b..c54d6d49ce 100644
--- a/datafusion/functions-nested/src/utils.rs
+++ b/datafusion/functions-nested/src/utils.rs
@@ -28,23 +28,12 @@ use arrow_array::{
use arrow_buffer::OffsetBuffer;
use arrow_schema::{Field, Fields};
use datafusion_common::cast::{as_large_list_array, as_list_array};
-use datafusion_common::{exec_err, internal_err, plan_err, Result, ScalarValue};
+use datafusion_common::{
+ exec_err, internal_datafusion_err, internal_err, plan_err, Result,
ScalarValue,
+};
-use core::any::type_name;
-use datafusion_common::DataFusionError;
use datafusion_expr::ColumnarValue;
-
-macro_rules! downcast_arg {
- ($ARG:expr, $ARRAY_TYPE:ident) => {{
- $ARG.as_any().downcast_ref::<$ARRAY_TYPE>().ok_or_else(|| {
- DataFusionError::Internal(format!(
- "could not cast to {}",
- type_name::<$ARRAY_TYPE>()
- ))
- })?
- }};
-}
-pub(crate) use downcast_arg;
+use datafusion_functions::{downcast_arg, downcast_named_arg};
pub(crate) fn check_datatypes(name: &str, args: &[&ArrayRef]) -> Result<()> {
let data_type = args[0].data_type();
diff --git a/datafusion/functions/src/macros.rs
b/datafusion/functions/src/macros.rs
index 8230860149..48eff4fcd4 100644
--- a/datafusion/functions/src/macros.rs
+++ b/datafusion/functions/src/macros.rs
@@ -109,24 +109,37 @@ macro_rules! make_stub_package {
};
}
-/// Downcast an argument to a specific array type, returning an internal error
+/// Downcast a named argument to a specific array type, returning an internal
error
/// if the cast fails
///
/// $ARG: ArrayRef
/// $NAME: name of the argument (for error messages)
/// $ARRAY_TYPE: the type of array to cast the argument to
-macro_rules! downcast_arg {
+#[macro_export]
+macro_rules! downcast_named_arg {
($ARG:expr, $NAME:expr, $ARRAY_TYPE:ident) => {{
$ARG.as_any().downcast_ref::<$ARRAY_TYPE>().ok_or_else(|| {
- DataFusionError::Internal(format!(
+ internal_datafusion_err!(
"could not cast {} to {}",
$NAME,
std::any::type_name::<$ARRAY_TYPE>()
- ))
+ )
})?
}};
}
+/// Downcast an argument to a specific array type, returning an internal error
+/// if the cast fails
+///
+/// $ARG: ArrayRef
+/// $ARRAY_TYPE: the type of array to cast the argument to
+#[macro_export]
+macro_rules! downcast_arg {
+ ($ARG:expr, $ARRAY_TYPE:ident) => {{
+ downcast_named_arg!($ARG, "", $ARRAY_TYPE)
+ }};
+}
+
/// Macro to create a unary math UDF.
///
/// A unary math function takes an argument of type Float32 or Float64,
diff --git a/datafusion/functions/src/math/abs.rs
b/datafusion/functions/src/math/abs.rs
index e3d448083e..1af5e0dfaf 100644
--- a/datafusion/functions/src/math/abs.rs
+++ b/datafusion/functions/src/math/abs.rs
@@ -26,7 +26,7 @@ use arrow::array::{
};
use arrow::datatypes::DataType;
use arrow::error::ArrowError;
-use datafusion_common::{exec_err, not_impl_err, DataFusionError, Result};
+use datafusion_common::{exec_err, internal_datafusion_err, not_impl_err,
Result};
use datafusion_expr::interval_arithmetic::Interval;
use datafusion_expr::sort_properties::{ExprProperties, SortProperties};
use datafusion_expr::{
@@ -39,7 +39,7 @@ type MathArrayFunction = fn(&Vec<ArrayRef>) ->
Result<ArrayRef>;
macro_rules! make_abs_function {
($ARRAY_TYPE:ident) => {{
|args: &Vec<ArrayRef>| {
- let array = downcast_arg!(&args[0], "abs arg", $ARRAY_TYPE);
+ let array = downcast_named_arg!(&args[0], "abs arg", $ARRAY_TYPE);
let res: $ARRAY_TYPE = array.unary(|x| x.abs());
Ok(Arc::new(res) as ArrayRef)
}
@@ -49,7 +49,7 @@ macro_rules! make_abs_function {
macro_rules! make_try_abs_function {
($ARRAY_TYPE:ident) => {{
|args: &Vec<ArrayRef>| {
- let array = downcast_arg!(&args[0], "abs arg", $ARRAY_TYPE);
+ let array = downcast_named_arg!(&args[0], "abs arg", $ARRAY_TYPE);
let res: $ARRAY_TYPE = array.try_unary(|x| {
x.checked_abs().ok_or_else(|| {
ArrowError::ComputeError(format!(
@@ -67,7 +67,7 @@ macro_rules! make_try_abs_function {
macro_rules! make_decimal_abs_function {
($ARRAY_TYPE:ident) => {{
|args: &Vec<ArrayRef>| {
- let array = downcast_arg!(&args[0], "abs arg", $ARRAY_TYPE);
+ let array = downcast_named_arg!(&args[0], "abs arg", $ARRAY_TYPE);
let res: $ARRAY_TYPE = array
.unary(|x| x.wrapping_abs())
.with_data_type(args[0].data_type().clone());
diff --git a/datafusion/functions/src/math/factorial.rs
b/datafusion/functions/src/math/factorial.rs
index 083936eb18..fcc6cb9f06 100644
--- a/datafusion/functions/src/math/factorial.rs
+++ b/datafusion/functions/src/math/factorial.rs
@@ -26,7 +26,9 @@ use arrow::datatypes::DataType;
use arrow::datatypes::DataType::Int64;
use crate::utils::make_scalar_function;
-use datafusion_common::{arrow_datafusion_err, exec_err, DataFusionError,
Result};
+use datafusion_common::{
+ arrow_datafusion_err, exec_err, internal_datafusion_err, DataFusionError,
Result,
+};
use datafusion_expr::scalar_doc_sections::DOC_SECTION_MATH;
use datafusion_expr::{
ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,
@@ -99,7 +101,7 @@ fn get_factorial_doc() -> &'static Documentation {
fn factorial(args: &[ArrayRef]) -> Result<ArrayRef> {
match args[0].data_type() {
Int64 => {
- let arg = downcast_arg!((&args[0]), "value", Int64Array);
+ let arg = downcast_named_arg!((&args[0]), "value", Int64Array);
Ok(arg
.iter()
.map(|a| match a {
diff --git a/datafusion/functions/src/math/gcd.rs
b/datafusion/functions/src/math/gcd.rs
index f4119cd975..36c9088966 100644
--- a/datafusion/functions/src/math/gcd.rs
+++ b/datafusion/functions/src/math/gcd.rs
@@ -25,7 +25,9 @@ use arrow::datatypes::DataType;
use arrow::datatypes::DataType::Int64;
use crate::utils::make_scalar_function;
-use datafusion_common::{arrow_datafusion_err, exec_err, DataFusionError,
Result};
+use datafusion_common::{
+ arrow_datafusion_err, exec_err, internal_datafusion_err, DataFusionError,
Result,
+};
use datafusion_expr::scalar_doc_sections::DOC_SECTION_MATH;
use datafusion_expr::{
ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,
@@ -100,8 +102,8 @@ fn get_gcd_doc() -> &'static Documentation {
fn gcd(args: &[ArrayRef]) -> Result<ArrayRef> {
match args[0].data_type() {
Int64 => {
- let arg1 = downcast_arg!(&args[0], "x", Int64Array);
- let arg2 = downcast_arg!(&args[1], "y", Int64Array);
+ let arg1 = downcast_named_arg!(&args[0], "x", Int64Array);
+ let arg2 = downcast_named_arg!(&args[1], "y", Int64Array);
Ok(arg1
.iter()
diff --git a/datafusion/functions/src/math/lcm.rs
b/datafusion/functions/src/math/lcm.rs
index 4e5a9b64f6..6e9a2a123f 100644
--- a/datafusion/functions/src/math/lcm.rs
+++ b/datafusion/functions/src/math/lcm.rs
@@ -23,7 +23,9 @@ use arrow::datatypes::DataType;
use arrow::datatypes::DataType::Int64;
use arrow::error::ArrowError;
-use datafusion_common::{arrow_datafusion_err, exec_err, DataFusionError,
Result};
+use datafusion_common::{
+ arrow_datafusion_err, exec_err, internal_datafusion_err, DataFusionError,
Result,
+};
use datafusion_expr::scalar_doc_sections::DOC_SECTION_MATH;
use datafusion_expr::{
ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,
@@ -121,8 +123,8 @@ fn lcm(args: &[ArrayRef]) -> Result<ArrayRef> {
match args[0].data_type() {
Int64 => {
- let arg1 = downcast_arg!(&args[0], "x", Int64Array);
- let arg2 = downcast_arg!(&args[1], "y", Int64Array);
+ let arg1 = downcast_named_arg!(&args[0], "x", Int64Array);
+ let arg2 = downcast_named_arg!(&args[1], "y", Int64Array);
Ok(arg1
.iter()
diff --git a/datafusion/functions/src/math/power.rs
b/datafusion/functions/src/math/power.rs
index 92dd8966b6..296b2dd3fe 100644
--- a/datafusion/functions/src/math/power.rs
+++ b/datafusion/functions/src/math/power.rs
@@ -24,8 +24,8 @@ use super::log::LogFunc;
use arrow::array::{ArrayRef, AsArray, Int64Array};
use arrow::datatypes::{ArrowNativeTypeOp, DataType, Float64Type};
use datafusion_common::{
- arrow_datafusion_err, exec_datafusion_err, exec_err, plan_datafusion_err,
- DataFusionError, Result, ScalarValue,
+ arrow_datafusion_err, exec_datafusion_err, exec_err,
internal_datafusion_err,
+ plan_datafusion_err, DataFusionError, Result, ScalarValue,
};
use datafusion_expr::expr::ScalarFunction;
use datafusion_expr::scalar_doc_sections::DOC_SECTION_MATH;
@@ -103,8 +103,8 @@ impl ScalarUDFImpl for PowerFunc {
Arc::new(result) as _
}
DataType::Int64 => {
- let bases = downcast_arg!(&args[0], "base", Int64Array);
- let exponents = downcast_arg!(&args[1], "exponent",
Int64Array);
+ let bases = downcast_named_arg!(&args[0], "base", Int64Array);
+ let exponents = downcast_named_arg!(&args[1], "exponent",
Int64Array);
bases
.iter()
.zip(exponents.iter())
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
