Plural types as Display

Author: emilk

Cargo.lock

@@ -51,6 +51,7 @@ datafusion-functions-aggregate-common = { workspace = true }
 datafusion-functions-window-common = { workspace = true }
 datafusion-physical-expr-common = { workspace = true }
 indexmap = { workspace = true }
+itertools = { workspace = true }
 paste = "^1.0"
 recursive = { workspace = true, optional = true }
 serde_json = { workspace = true }

datafusion/expr/Cargo.toml

@@ -20,6 +20,7 @@ use crate::expr::Case;
 use crate::{expr_schema::ExprSchemable, Expr};
 use arrow::datatypes::DataType;
 use datafusion_common::{plan_err, DFSchema, HashSet, Result};
+use itertools::Itertools as _;
 
 /// Helper struct for building [Expr::Case]
 pub struct CaseBuilder {
@@ -83,7 +84,8 @@ impl CaseBuilder {
             let unique_types: HashSet<&DataType> = then_types.iter().collect();
             if unique_types.len() != 1 {
                 return plan_err!(
-                    "CASE expression 'then' values had multiple data types: {unique_types:?}"
+                    "CASE expression 'then' values had multiple data types: {}",
+                    unique_types.iter().join(", ")
                 );
             }
         }

datafusion/expr/src/conditional_expressions.rs

@@ -17,6 +17,7 @@
 
 use arrow::datatypes::DataType;
 use datafusion_common::{DFSchema, DFSchemaRef};
+use itertools::Itertools as _;
 use std::fmt::{self, Display};
 use std::sync::{Arc, LazyLock};
 
@@ -110,7 +111,7 @@ impl Statement {
                     Statement::Prepare(Prepare {
                         name, data_types, ..
                     }) => {
-                        write!(f, "Prepare: {name:?} {data_types:?}")
+                        write!(f, "Prepare: {name:?} {}", data_types.iter().join(", "))
                     }
                     Statement::Execute(Execute {
                         name, parameters, ..

datafusion/expr/src/logical_plan/statement.rs

@@ -36,6 +36,7 @@ use datafusion_expr_common::{
     type_coercion::binary::comparison_coercion_numeric,
     type_coercion::binary::string_coercion,
 };
+use itertools::Itertools as _;
 use std::sync::Arc;
 
 /// Performs type coercion for scalar function arguments.
@@ -278,7 +279,8 @@ fn try_coerce_types(
 
     // none possible -> Error
     plan_err!(
-        "Failed to coerce arguments to satisfy a call to '{function_name}' function: coercion from {current_types:?} to the signature {type_signature:?} failed"
+        "Failed to coerce arguments to satisfy a call to '{function_name}' function: coercion from {} to the signature {type_signature:?} failed",
+        current_types.iter().join(", ")
     )
 }
 

datafusion/expr/src/type_coercion/functions.rs

@@ -319,8 +319,9 @@ impl ScalarUDFImpl for ArrayConcat {
             }
         } else {
             plan_err!(
-                "Failed to unify argument types of {}: {arg_types:?}",
-                self.name()
+                "Failed to unify argument types of {}: {}",
+                self.name(),
+                arg_types.iter().join(", ")
             )
         }
     }

datafusion/functions-nested/src/concat.rs

@@ -39,6 +39,7 @@ use datafusion_expr::{
     ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,
 };
 use datafusion_macros::user_doc;
+use itertools::Itertools as _;
 
 make_udf_expr_and_func!(
     MakeArray,
@@ -132,8 +133,9 @@ impl ScalarUDFImpl for MakeArray {
             Ok(vec![unified; arg_types.len()])
         } else {
             plan_err!(
-                "Failed to unify argument types of {}: {arg_types:?}",
-                self.name()
+                "Failed to unify argument types of {}: {}",
+                self.name(),
+                arg_types.iter().join(", ")
             )
         }
     }

datafusion/functions-nested/src/make_array.rs

@@ -31,6 +31,7 @@ use datafusion_common::cast::{
 use datafusion_common::{exec_err, internal_err, plan_err, Result, ScalarValue};
 
 use datafusion_expr::ColumnarValue;
+use itertools::Itertools as _;
 
 pub(crate) fn check_datatypes(name: &str, args: &[&ArrayRef]) -> Result<()> {
     let data_type = args[0].data_type();
@@ -39,7 +40,10 @@ pub(crate) fn check_datatypes(name: &str, args: &[&ArrayRef]) -> Result<()> {
             || arg.data_type().equals_datatype(&DataType::Null)
     }) {
         let types = args.iter().map(|arg| arg.data_type()).collect::<Vec<_>>();
-        return plan_err!("{name} received incompatible types: '{types:?}'.");
+        return plan_err!(
+            "{name} received incompatible types: '{}'.",
+            types.iter().join(", ")
+        );
     }
 
     Ok(())

datafusion/functions-nested/src/utils.rs

@@ -20,7 +20,7 @@
 use std::sync::Arc;
 
 use datafusion_expr::binary::BinaryTypeCoercer;
-use itertools::izip;
+use itertools::{izip, Itertools as _};
 
 use arrow::datatypes::{DataType, Field, IntervalUnit, Schema};
 
@@ -479,7 +479,7 @@ impl TreeNodeRewriter for TypeCoercionRewriter<'_> {
                     get_coerce_type_for_list(&expr_data_type, &list_data_types);
                 match result_type {
                     None => plan_err!(
-                        "Can not find compatible types to compare {expr_data_type} with {list_data_types:?}"
+                        "Can not find compatible types to compare {expr_data_type} with {}", list_data_types.iter().join(", ")
                     ),
                     Some(coerced_type) => {
                         // find the coerced type
@@ -897,8 +897,9 @@ fn coerce_case_expression(case: Case, schema: &DFSchema) -> Result<Case> {
                 get_coerce_type_for_case_expression(&when_types, Some(case_type));
             coerced_type.ok_or_else(|| {
                 plan_datafusion_err!(
-                    "Failed to coerce case ({case_type}) and when ({when_types:?}) \
-                     to common types in CASE WHEN expression"
+                    "Failed to coerce case ({case_type}) and when ({}) \
+                     to common types in CASE WHEN expression",
+                    when_types.iter().join(", ")
                 )
             })
         })
@@ -908,13 +909,15 @@ fn coerce_case_expression(case: Case, schema: &DFSchema) -> Result<Case> {
             || {
                 if let Some(else_type) = else_type {
                     plan_datafusion_err!(
-                        "Failed to coerce then ({then_types:?}) and else ({else_type}) \
-                         to common types in CASE WHEN expression"
+                        "Failed to coerce then ({}) and else ({else_type}) \
+                         to common types in CASE WHEN expression",
+                        then_types.iter().join(", ")
                     )
                 } else {
                     plan_datafusion_err!(
-                        "Failed to coerce then ({then_types:?}) and else (None) \
-                         to common types in CASE WHEN expression"
+                        "Failed to coerce then ({}) and else (None) \
+                         to common types in CASE WHEN expression",
+                        then_types.iter().join(", ")
                     )
                 }
             },

datafusion/optimizer/src/analyzer/type_coercion.rs

@@ -488,7 +488,8 @@ mod tests {
         let result_type = get_coerce_type(expr_type, &list_types);
         match result_type {
             None => plan_err!(
-                "Can not find compatible types to compare {expr_type} with {list_types:?}"
+                "Can not find compatible types to compare {expr_type} with {}",
+                list_types.iter().join(", ")
             ),
             Some(data_type) => {
                 // find the coerced type