Apache DataFusion SQL Query Engine
Improve formatting of datatypes (#20605)
Emil Ernerfeldt3b028fe6774b
diff --git a/Cargo.lock b/Cargo.lockindex 23670a7877..beb87f615c 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2176,6 +2176,7 @@ dependencies = ["arrow","datafusion-common","indexmap 2.13.0",+ "insta","itertools 0.14.0","paste",]diff --git a/datafusion/common/src/types/logical.rs b/datafusion/common/src/types/logical.rsindex 674b1a4120..0f886252d6 100644--- a/datafusion/common/src/types/logical.rs+++ b/datafusion/common/src/types/logical.rs@@ -100,7 +100,10 @@ impl fmt::Debug for dyn LogicalType {impl std::fmt::Display for dyn LogicalType {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- write!(f, "{self:?}")+ match self.signature() {+ TypeSignature::Native(_) => write!(f, "{}", self.native()),+ TypeSignature::Extension { name, .. } => write!(f, "{name}"),+ }}}@@ -132,3 +135,118 @@ impl Hash for dyn LogicalType {self.signature().hash(state);}}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::types::{+ LogicalField, LogicalFields, logical_boolean, logical_date, logical_float32,+ logical_float64, logical_int32, logical_int64, logical_null, logical_string,+ };+ use arrow::datatypes::{DataType, Field, Fields};+ use insta::assert_snapshot;++ #[test]+ fn test_logical_type_display_simple() {+ assert_snapshot!(logical_null(), @"Null");+ assert_snapshot!(logical_boolean(), @"Boolean");+ assert_snapshot!(logical_int32(), @"Int32");+ assert_snapshot!(logical_int64(), @"Int64");+ assert_snapshot!(logical_float32(), @"Float32");+ assert_snapshot!(logical_float64(), @"Float64");+ assert_snapshot!(logical_string(), @"String");+ assert_snapshot!(logical_date(), @"Date");+ }++ #[test]+ fn test_logical_type_display_list() {+ let list_type: Arc<dyn LogicalType> = Arc::new(NativeType::List(Arc::new(+ LogicalField::from(&Field::new("item", DataType::Int32, true)),+ )));+ assert_snapshot!(list_type, @"List(Int32)");+ }++ #[test]+ fn test_logical_type_display_struct() {+ let struct_type: Arc<dyn LogicalType> = Arc::new(NativeType::Struct(+ LogicalFields::from(&Fields::from(vec![+ Field::new("x", DataType::Float64, false),+ Field::new("y", DataType::Float64, true),+ ])),+ ));+ assert_snapshot!(struct_type, @r#"Struct("x": non-null Float64, "y": Float64)"#);+ }++ #[test]+ fn test_logical_type_display_fixed_size_list() {+ let fsl_type: Arc<dyn LogicalType> = Arc::new(NativeType::FixedSizeList(+ Arc::new(LogicalField::from(&Field::new(+ "item",+ DataType::Float32,+ false,+ ))),+ 3,+ ));+ assert_snapshot!(fsl_type, @"FixedSizeList(3 x non-null Float32)");+ }++ #[test]+ fn test_logical_type_display_map() {+ let map_type: Arc<dyn LogicalType> = Arc::new(NativeType::Map(Arc::new(+ LogicalField::from(&Field::new("entries", DataType::Utf8, false)),+ )));+ assert_snapshot!(map_type, @"Map(non-null String)");+ }++ #[test]+ fn test_logical_type_display_union() {+ use arrow::datatypes::UnionFields;++ let union_fields = UnionFields::try_new(+ vec![0, 1],+ vec![+ Field::new("int_val", DataType::Int32, false),+ Field::new("str_val", DataType::Utf8, true),+ ],+ )+ .unwrap();+ let union_type: Arc<dyn LogicalType> = Arc::new(NativeType::Union(+ crate::types::LogicalUnionFields::from(&union_fields),+ ));+ assert_snapshot!(union_type, @r#"Union(0: ("int_val": non-null Int32), 1: ("str_val": String))"#);+ }++ #[test]+ fn test_logical_type_display_nullable_vs_non_nullable() {+ let nullable_list: Arc<dyn LogicalType> = Arc::new(NativeType::List(Arc::new(+ LogicalField::from(&Field::new("item", DataType::Int32, true)),+ )));+ let non_nullable_list: Arc<dyn LogicalType> =+ Arc::new(NativeType::List(Arc::new(LogicalField::from(&Field::new(+ "item",+ DataType::Int32,+ false,+ )))));++ assert_snapshot!(nullable_list, @"List(Int32)");+ assert_snapshot!(non_nullable_list, @"List(non-null Int32)");+ }++ #[test]+ fn test_logical_type_display_extension() {+ struct JsonType;+ impl LogicalType for JsonType {+ fn native(&self) -> &NativeType {+ &NativeType::String+ }+ fn signature(&self) -> TypeSignature<'_> {+ TypeSignature::Extension {+ name: "JSON",+ parameters: &[],+ }+ }+ }+ let json: Arc<dyn LogicalType> = Arc::new(JsonType);+ assert_snapshot!(json, @"JSON");+ }+}diff --git a/datafusion/common/src/types/native.rs b/datafusion/common/src/types/native.rsindex 65b6a5a15f..a4202db986 100644--- a/datafusion/common/src/types/native.rs+++ b/datafusion/common/src/types/native.rs@@ -184,6 +184,16 @@ pub enum NativeType {Map(LogicalFieldRef),}+/// Format a [`LogicalField`] for display, matching [`arrow::datatypes::DataType`]'s+/// Display convention of showing a `"non-null "` prefix for non-nullable fields.+fn format_logical_field(+ f: &mut std::fmt::Formatter<'_>,+ field: &LogicalField,+) -> std::fmt::Result {+ let non_null = if field.nullable { "" } else { "non-null " };+ write!(f, "{:?}: {non_null}{}", field.name, field.logical_type)+}+impl Display for NativeType {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {// Match the format used by arrow::datatypes::DataType's Display impl@@ -210,9 +220,17 @@ impl Display for NativeType {Self::Binary => write!(f, "Binary"),Self::FixedSizeBinary(size) => write!(f, "FixedSizeBinary({size})"),Self::String => write!(f, "String"),- Self::List(field) => write!(f, "List({})", field.logical_type),+ Self::List(field) => {+ let non_null = if field.nullable { "" } else { "non-null " };+ write!(f, "List({non_null}{})", field.logical_type)+ }Self::FixedSizeList(field, size) => {- write!(f, "FixedSizeList({size} x {})", field.logical_type)+ let non_null = if field.nullable { "" } else { "non-null " };+ write!(+ f,+ "FixedSizeList({size} x {non_null}{})",+ field.logical_type+ )}Self::Struct(fields) => {write!(f, "Struct(")?;@@ -220,7 +238,7 @@ impl Display for NativeType {if i > 0 {write!(f, ", ")?;}- write!(f, "{:?}: {}", field.name, field.logical_type)?;+ format_logical_field(f, field)?;}write!(f, ")")}@@ -230,12 +248,17 @@ impl Display for NativeType {if i > 0 {write!(f, ", ")?;}- write!(f, "{type_id}: ({:?}: {})", field.name, field.logical_type)?;+ write!(f, "{type_id}: (")?;+ format_logical_field(f, field)?;+ write!(f, ")")?;}write!(f, ")")}Self::Decimal(precision, scale) => write!(f, "Decimal({precision}, {scale})"),- Self::Map(field) => write!(f, "Map({})", field.logical_type),+ Self::Map(field) => {+ let non_null = if field.nullable { "" } else { "non-null " };+ write!(f, "Map({non_null}{})", field.logical_type)+ }}}}@@ -537,3 +560,90 @@ impl NativeType {matches!(self, Self::Float16 | Self::Float32 | Self::Float64)}}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::types::LogicalField;+ use arrow::datatypes::Field;+ use insta::assert_snapshot;++ #[test]+ fn test_native_type_display() {+ assert_snapshot!(NativeType::Null, @"Null");+ assert_snapshot!(NativeType::Boolean, @"Boolean");+ assert_snapshot!(NativeType::Int8, @"Int8");+ assert_snapshot!(NativeType::Int16, @"Int16");+ assert_snapshot!(NativeType::Int32, @"Int32");+ assert_snapshot!(NativeType::Int64, @"Int64");+ assert_snapshot!(NativeType::UInt8, @"UInt8");+ assert_snapshot!(NativeType::UInt16, @"UInt16");+ assert_snapshot!(NativeType::UInt32, @"UInt32");+ assert_snapshot!(NativeType::UInt64, @"UInt64");+ assert_snapshot!(NativeType::Float16, @"Float16");+ assert_snapshot!(NativeType::Float32, @"Float32");+ assert_snapshot!(NativeType::Float64, @"Float64");+ assert_snapshot!(NativeType::Date, @"Date");+ assert_snapshot!(NativeType::Binary, @"Binary");+ assert_snapshot!(NativeType::String, @"String");+ assert_snapshot!(NativeType::FixedSizeBinary(16), @"FixedSizeBinary(16)");+ assert_snapshot!(NativeType::Decimal(10, 2), @"Decimal(10, 2)");+ }++ #[test]+ fn test_native_type_display_timestamp() {+ assert_snapshot!(+ NativeType::Timestamp(TimeUnit::Second, None),+ @"Timestamp(s)"+ );+ assert_snapshot!(+ NativeType::Timestamp(TimeUnit::Millisecond, None),+ @"Timestamp(ms)"+ );+ assert_snapshot!(+ NativeType::Timestamp(TimeUnit::Nanosecond, Some(Arc::from("UTC"))),+ @r#"Timestamp(ns, "UTC")"#+ );+ }++ #[test]+ fn test_native_type_display_time_duration_interval() {+ assert_snapshot!(NativeType::Time(TimeUnit::Microsecond), @"Time(µs)");+ assert_snapshot!(NativeType::Duration(TimeUnit::Nanosecond), @"Duration(ns)");+ assert_snapshot!(NativeType::Interval(IntervalUnit::YearMonth), @"Interval(YearMonth)");+ assert_snapshot!(NativeType::Interval(IntervalUnit::MonthDayNano), @"Interval(MonthDayNano)");+ }++ #[test]+ fn test_native_type_display_nested() {+ let list = NativeType::List(Arc::new(LogicalField::from(&Field::new(+ "item",+ DataType::Int32,+ true,+ ))));+ assert_snapshot!(list, @"List(Int32)");++ let fixed_list = NativeType::FixedSizeList(+ Arc::new(LogicalField::from(&Field::new(+ "item",+ DataType::Float64,+ false,+ ))),+ 3,+ );+ assert_snapshot!(fixed_list, @"FixedSizeList(3 x non-null Float64)");++ let struct_type = NativeType::Struct(LogicalFields::from(&Fields::from(vec![+ Field::new("name", DataType::Utf8, false),+ Field::new("age", DataType::Int32, true),+ ])));+ assert_snapshot!(struct_type, @r#"Struct("name": non-null String, "age": Int32)"#);++ let map = NativeType::Map(Arc::new(LogicalField::from(&Field::new(+ "entries",+ DataType::Utf8,+ false,+ ))));+ assert_snapshot!(map, @"Map(non-null String)");+ }+}diff --git a/datafusion/expr-common/Cargo.toml b/datafusion/expr-common/Cargo.tomlindex 5ee46b454e..d66d8ee858 100644--- a/datafusion/expr-common/Cargo.toml+++ b/datafusion/expr-common/Cargo.toml@@ -46,3 +46,6 @@ datafusion-common = { workspace = true }indexmap = { workspace = true }itertools = { workspace = true }paste = { workspace = true }++[dev-dependencies]+insta = { workspace = true }diff --git a/datafusion/expr-common/src/signature.rs b/datafusion/expr-common/src/signature.rsindex 857e9dc5d4..82759be9f7 100644--- a/datafusion/expr-common/src/signature.rs+++ b/datafusion/expr-common/src/signature.rs@@ -322,6 +322,43 @@ impl TypeSignature {}}+impl Display for TypeSignature {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ TypeSignature::Variadic(types) => {+ write!(f, "Variadic({})", types.iter().join(", "))+ }+ TypeSignature::UserDefined => write!(f, "UserDefined"),+ TypeSignature::VariadicAny => write!(f, "VariadicAny"),+ TypeSignature::Uniform(count, types) => {+ write!(f, "Uniform({count}, [{}])", types.iter().join(", "))+ }+ TypeSignature::Exact(types) => {+ write!(f, "Exact({})", types.iter().join(", "))+ }+ TypeSignature::Coercible(coercions) => {+ write!(f, "Coercible({})", coercions.iter().join(", "))+ }+ TypeSignature::Comparable(count) => write!(f, "Comparable({count})"),+ TypeSignature::Any(count) => write!(f, "Any({count})"),+ TypeSignature::OneOf(sigs) => {+ write!(f, "OneOf(")?;+ for (i, sig) in sigs.iter().enumerate() {+ if i > 0 {+ write!(f, ", ")?;+ }+ write!(f, "{sig}")?;+ }+ write!(f, ")")+ }+ TypeSignature::ArraySignature(sig) => write!(f, "ArraySignature({sig})"),+ TypeSignature::Numeric(count) => write!(f, "Numeric({count})"),+ TypeSignature::String(count) => write!(f, "String({count})"),+ TypeSignature::Nullary => write!(f, "Nullary"),+ }+ }+}+/// Represents the class of types that can be used in a function signature.////// This is used to specify what types are valid for function arguments in a more flexible way than@@ -358,7 +395,19 @@ pub enum TypeSignatureClass {impl Display for TypeSignatureClass {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- write!(f, "TypeSignatureClass::{self:?}")+ match self {+ Self::Any => write!(f, "Any"),+ Self::Timestamp => write!(f, "Timestamp"),+ Self::Time => write!(f, "Time"),+ Self::Interval => write!(f, "Interval"),+ Self::Duration => write!(f, "Duration"),+ Self::Native(logical_type) => write!(f, "{logical_type}"),+ Self::Integer => write!(f, "Integer"),+ Self::Float => write!(f, "Float"),+ Self::Decimal => write!(f, "Decimal"),+ Self::Numeric => write!(f, "Numeric"),+ Self::Binary => write!(f, "Binary"),+ }}}@@ -1062,12 +1111,7 @@ impl Coercion {impl Display for Coercion {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- write!(f, "Coercion({}", self.desired_type())?;- if let Some(implicit_coercion) = self.implicit_coercion() {- write!(f, ", implicit_coercion={implicit_coercion}",)- } else {- write!(f, ")")- }+ write!(f, "{}", self.desired_type())}}@@ -1119,11 +1163,14 @@ pub struct ImplicitCoercion {impl Display for ImplicitCoercion {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- write!(- f,- "ImplicitCoercion({:?}, default_type={:?})",- self.allowed_source_types, self.default_casted_type- )+ write!(f, "ImplicitCoercion(")?;+ for (i, source_type) in self.allowed_source_types.iter().enumerate() {+ if i > 0 {+ write!(f, ", ")?;+ }+ write!(f, "{source_type}")?;+ }+ write!(f, "; default={}", self.default_casted_type)}}@@ -1438,7 +1485,9 @@ impl Signature {#[cfg(test)]mod tests {- use datafusion_common::types::{logical_int32, logical_int64, logical_string};+ use datafusion_common::types::{+ NativeType, logical_float64, logical_int32, logical_int64, logical_string,+ };use super::*;use crate::signature::{@@ -2034,4 +2083,124 @@ mod tests {let sig = TypeSignature::UserDefined;assert_eq!(sig.arity(), Arity::Variable);}++ #[test]+ fn test_type_signature_display() {+ use insta::assert_snapshot;++ assert_snapshot!(TypeSignature::Nullary, @"Nullary");+ assert_snapshot!(TypeSignature::Any(2), @"Any(2)");+ assert_snapshot!(TypeSignature::Numeric(3), @"Numeric(3)");+ assert_snapshot!(TypeSignature::String(1), @"String(1)");+ assert_snapshot!(TypeSignature::Comparable(2), @"Comparable(2)");+ assert_snapshot!(TypeSignature::VariadicAny, @"VariadicAny");+ assert_snapshot!(TypeSignature::UserDefined, @"UserDefined");++ assert_snapshot!(+ TypeSignature::Exact(vec![DataType::Int32, DataType::Utf8]),+ @"Exact(Int32, Utf8)"+ );+ assert_snapshot!(+ TypeSignature::Variadic(vec![DataType::Utf8, DataType::LargeUtf8]),+ @"Variadic(Utf8, LargeUtf8)"+ );+ assert_snapshot!(+ TypeSignature::Uniform(2, vec![DataType::Float32, DataType::Float64]),+ @"Uniform(2, [Float32, Float64])"+ );++ assert_snapshot!(+ TypeSignature::Coercible(vec![+ Coercion::new_exact(TypeSignatureClass::Native(logical_float64())),+ Coercion::new_exact(TypeSignatureClass::Native(logical_int32())),+ ]),+ @"Coercible(Float64, Int32)"+ );++ assert_snapshot!(+ TypeSignature::OneOf(vec![+ TypeSignature::Nullary,+ TypeSignature::VariadicAny,+ ]),+ @"OneOf(Nullary, VariadicAny)"+ );+ }++ #[test]+ fn test_type_signature_class_display() {+ use insta::assert_snapshot;++ assert_snapshot!(TypeSignatureClass::Any, @"Any");+ assert_snapshot!(TypeSignatureClass::Numeric, @"Numeric");+ assert_snapshot!(TypeSignatureClass::Integer, @"Integer");+ assert_snapshot!(TypeSignatureClass::Float, @"Float");+ assert_snapshot!(TypeSignatureClass::Decimal, @"Decimal");+ assert_snapshot!(TypeSignatureClass::Timestamp, @"Timestamp");+ assert_snapshot!(TypeSignatureClass::Time, @"Time");+ assert_snapshot!(TypeSignatureClass::Interval, @"Interval");+ assert_snapshot!(TypeSignatureClass::Duration, @"Duration");+ assert_snapshot!(TypeSignatureClass::Binary, @"Binary");+ assert_snapshot!(TypeSignatureClass::Native(logical_int32()), @"Int32");+ assert_snapshot!(TypeSignatureClass::Native(logical_string()), @"String");+ }++ #[test]+ fn test_coercion_display() {+ use insta::assert_snapshot;++ let exact_int = Coercion::new_exact(TypeSignatureClass::Native(logical_int32()));+ assert_snapshot!(exact_int, @"Int32");++ let exact_numeric = Coercion::new_exact(TypeSignatureClass::Numeric);+ assert_snapshot!(exact_numeric, @"Numeric");++ let implicit = Coercion::new_implicit(+ TypeSignatureClass::Native(logical_float64()),+ vec![TypeSignatureClass::Numeric],+ NativeType::Float64,+ );+ assert_snapshot!(implicit, @"Float64");++ let implicit_with_multiple_sources = Coercion::new_implicit(+ TypeSignatureClass::Native(logical_int64()),+ vec![TypeSignatureClass::Integer, TypeSignatureClass::Numeric],+ NativeType::Int64,+ );+ assert_snapshot!(implicit_with_multiple_sources, @"Int64");+ }++ #[test]+ fn test_to_string_repr_coercible() {+ use insta::assert_snapshot;++ // Simulates a function like round(Float64, Int64) with coercion+ let sig = TypeSignature::Coercible(vec![+ Coercion::new_implicit(+ TypeSignatureClass::Native(logical_float64()),+ vec![TypeSignatureClass::Numeric],+ NativeType::Float64,+ ),+ Coercion::new_implicit(+ TypeSignatureClass::Native(logical_int64()),+ vec![TypeSignatureClass::Integer],+ NativeType::Int64,+ ),+ ]);+ let repr = sig.to_string_repr();+ assert_eq!(repr.len(), 1);+ assert_snapshot!(repr[0], @"Float64, Int64");+ }++ #[test]+ fn test_to_string_repr_coercible_exact() {+ use insta::assert_snapshot;++ let sig = TypeSignature::Coercible(vec![+ Coercion::new_exact(TypeSignatureClass::Native(logical_string())),+ Coercion::new_exact(TypeSignatureClass::Native(logical_int64())),+ ]);+ let repr = sig.to_string_repr();+ assert_eq!(repr.len(), 1);+ assert_snapshot!(repr[0], @"String, Int64");+ }}diff --git a/datafusion/expr-common/src/type_coercion/aggregates.rs b/datafusion/expr-common/src/type_coercion/aggregates.rsindex ab4d086e4c..df86ff582d 100644--- a/datafusion/expr-common/src/type_coercion/aggregates.rs+++ b/datafusion/expr-common/src/type_coercion/aggregates.rs@@ -61,8 +61,7 @@ pub fn check_arg_count(TypeSignature::Uniform(agg_count, _) | TypeSignature::Any(agg_count) => {if input_fields.len() != *agg_count {return plan_err!(- "The function {func_name} expects {:?} arguments, but {:?} were provided",- agg_count,+ "The function {func_name} expects {agg_count} arguments, but {} were provided",input_fields.len());}@@ -70,7 +69,7 @@ pub fn check_arg_count(TypeSignature::Exact(types) => {if types.len() != input_fields.len() {return plan_err!(- "The function {func_name} expects {:?} arguments, but {:?} were provided",+ "The function {func_name} expects {} arguments, but {} were provided",types.len(),input_fields.len());@@ -82,7 +81,7 @@ pub fn check_arg_count(.any(|v| check_arg_count(func_name, input_fields, v).is_ok());if !ok {return plan_err!(- "The function {func_name} does not accept {:?} function arguments.",+ "The function {func_name} does not accept {} function arguments.",input_fields.len());}@@ -101,9 +100,7 @@ pub fn check_arg_count(// Numeric and Coercible signature is validated in `get_valid_types`}_ => {- return internal_err!(- "Aggregate functions do not support this {signature:?}"- );+ return internal_err!("Aggregate functions do not support this {signature}");}}Ok(())diff --git a/datafusion/expr-common/src/type_coercion/binary.rs b/datafusion/expr-common/src/type_coercion/binary.rsindex c6ac86cd39..dd3db8e40b 100644--- a/datafusion/expr-common/src/type_coercion/binary.rs+++ b/datafusion/expr-common/src/type_coercion/binary.rs@@ -753,15 +753,15 @@ fn type_union_resolution_coercion(/// Handle type union resolution including struct type and others.pub fn try_type_union_resolution(data_types: &[DataType]) -> Result<Vec<DataType>> {- let err = match try_type_union_resolution_with_struct(data_types) {+ let struct_err = match try_type_union_resolution_with_struct(data_types) {Ok(struct_types) => return Ok(struct_types),- Err(e) => Some(e),+ Err(e) => e,};if let Some(new_type) = type_union_resolution(data_types) {Ok(vec![new_type; data_types.len()])} else {- exec_err!("Fail to find the coerced type, errors: {:?}", err)+ exec_err!("Fail to find the coerced type, errors: {struct_err}")}}diff --git a/datafusion/expr/src/expr_schema.rs b/datafusion/expr/src/expr_schema.rsindex f2ac777af3..4168310002 100644--- a/datafusion/expr/src/expr_schema.rs+++ b/datafusion/expr/src/expr_schema.rs@@ -649,7 +649,7 @@ fn verify_function_arguments<F: UDFCoercionExt>(.cloned().collect::<Vec<_>>();plan_datafusion_err!(- "{} {}",+ "{}. {}",match err {DataFusionError::Plan(msg) => msg,err => err.to_string(),diff --git a/datafusion/expr/src/type_coercion/functions.rs b/datafusion/expr/src/type_coercion/functions.rsindex fe259fb8c9..a79f2c6683 100644--- a/datafusion/expr/src/type_coercion/functions.rs+++ b/datafusion/expr/src/type_coercion/functions.rs@@ -221,12 +221,12 @@ pub fn data_types(} else if type_signature.used_to_support_zero_arguments() {// Special error to help during upgrade: https://github.com/apache/datafusion/issues/13763return plan_err!(- "function '{}' has signature {type_signature:?} which does not support zero arguments. Use TypeSignature::Nullary for zero arguments",+ "function '{}' has signature {type_signature} which does not support zero arguments. Use TypeSignature::Nullary for zero arguments",function_name.as_ref());} else {return plan_err!(- "Function '{}' has signature {type_signature:?} which does not support zero arguments",+ "Function '{}' has signature {type_signature} which does not support zero arguments",function_name.as_ref());}@@ -302,7 +302,7 @@ fn try_coerce_types(// none possible -> Errorplan_err!(- "Failed to coerce arguments to satisfy a call to '{function_name}' function: coercion from {} 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(", "))}@@ -317,7 +317,7 @@ fn get_valid_types_with_udf<F: UDFCoercionExt>(Ok(coerced_types) => vec![coerced_types],Err(e) => {return exec_err!(- "Function '{}' user-defined coercion failed with {:?}",+ "Function '{}' user-defined coercion failed with: {}",func.name(),e.strip_backtrace());@@ -502,7 +502,7 @@ fn get_valid_types(new_types.push(DataType::Utf8);} else {return plan_err!(- "Function '{function_name}' expects NativeType::String but NativeType::received NativeType::{logical_data_type}"+ "Function '{function_name}' expects String but received {logical_data_type}");}}@@ -562,7 +562,7 @@ fn get_valid_types(if !logical_data_type.is_numeric() {return plan_err!(- "Function '{function_name}' expects NativeType::Numeric but received NativeType::{logical_data_type}"+ "Function '{function_name}' expects Numeric but received {logical_data_type}");}@@ -583,7 +583,7 @@ fn get_valid_types(valid_type = DataType::Float64;} else if !logical_data_type.is_numeric() {return plan_err!(- "Function '{function_name}' expects NativeType::Numeric but received NativeType::{logical_data_type}"+ "Function '{function_name}' expects Numeric but received {logical_data_type}");}@@ -1056,7 +1056,7 @@ mod tests {.unwrap_err();assert_contains!(got.to_string(),- "Function 'test' expects NativeType::Numeric but received NativeType::String"+ "Function 'test' expects Numeric but received String");// Fallbacks to float64 if the arg is of type null.@@ -1076,7 +1076,7 @@ mod tests {.unwrap_err();assert_contains!(got.to_string(),- "Function 'test' expects NativeType::Numeric but received NativeType::Timestamp(s)"+ "Function 'test' expects Numeric but received Timestamp(s)");Ok(())diff --git a/datafusion/expr/src/udf.rs b/datafusion/expr/src/udf.rsindex 405fb25680..9705006e41 100644--- a/datafusion/expr/src/udf.rs+++ b/datafusion/expr/src/udf.rs@@ -261,7 +261,7 @@ impl ScalarUDF {let expected_type = return_field.data_type();assert_or_internal_err!(result_data_type == *expected_type,- "Function '{}' returned value of type '{:?}' while the following type was promised at planning time and expected: '{:?}'",+ "Function '{}' returned value of type '{}' while the following type was promised at planning time and expected: '{}'",self.name(),result_data_type,expected_typediff --git a/datafusion/expr/src/utils.rs b/datafusion/expr/src/utils.rsindex b19299981c..81a6fd393a 100644--- a/datafusion/expr/src/utils.rs+++ b/datafusion/expr/src/utils.rs@@ -1784,4 +1784,104 @@ mod tests {"Expected 'Any, Any' without parameter names, got: {error_msg}");}++ #[test]+ fn test_signature_error_msg_exact() {+ use insta::assert_snapshot;++ let sig = Signature::one_of(+ vec![+ TypeSignature::Exact(vec![DataType::Float64, DataType::Int64]),+ TypeSignature::Exact(vec![DataType::Float32, DataType::Int64]),+ TypeSignature::Exact(vec![DataType::Float64]),+ TypeSignature::Exact(vec![DataType::Float32]),+ ],+ Volatility::Immutable,+ );+ let msg = generate_signature_error_message(+ "round",+ &sig,+ &[DataType::Float64, DataType::Float64],+ );+ assert_snapshot!(msg, @r"+ No function matches the given name and argument types 'round(Float64, Float64)'. You might need to add explicit type casts.+ Candidate functions:+ round(Float64, Int64)+ round(Float32, Int64)+ round(Float64)+ round(Float32)+ ");+ }++ #[test]+ fn test_signature_error_msg_coercible() {+ use datafusion_common::types::NativeType;+ use datafusion_expr_common::signature::{Coercion, TypeSignatureClass};+ use insta::assert_snapshot;++ let sig = Signature::coercible(+ vec![+ Coercion::new_implicit(+ TypeSignatureClass::Native(+ datafusion_common::types::logical_float64(),+ ),+ vec![TypeSignatureClass::Numeric],+ NativeType::Float64,+ ),+ Coercion::new_implicit(+ TypeSignatureClass::Native(datafusion_common::types::logical_int64()),+ vec![TypeSignatureClass::Integer],+ NativeType::Int64,+ ),+ ],+ Volatility::Immutable,+ );+ let msg = generate_signature_error_message(+ "round",+ &sig,+ &[DataType::Utf8, DataType::Utf8],+ );+ assert_snapshot!(msg, @r"+ No function matches the given name and argument types 'round(Utf8, Utf8)'. You might need to add explicit type casts.+ Candidate functions:+ round(Float64, Int64)+ ");+ }++ #[test]+ fn test_signature_error_msg_with_names_coercible() {+ use datafusion_common::types::NativeType;+ use datafusion_expr_common::signature::{Coercion, TypeSignatureClass};+ use insta::assert_snapshot;++ let sig = Signature::coercible(+ vec![+ Coercion::new_exact(TypeSignatureClass::Native(+ datafusion_common::types::logical_string(),+ )),+ Coercion::new_exact(TypeSignatureClass::Native(+ datafusion_common::types::logical_int64(),+ )),+ Coercion::new_implicit(+ TypeSignatureClass::Native(datafusion_common::types::logical_int64()),+ vec![TypeSignatureClass::Integer],+ NativeType::Int64,+ ),+ ],+ Volatility::Immutable,+ )+ .with_parameter_names(vec![+ "string".to_string(),+ "start_pos".to_string(),+ "length".to_string(),+ ])+ .expect("valid parameter names");++ let msg = generate_signature_error_message("substr", &sig, &[DataType::Int32]);+ assert_snapshot!(msg, @r"+ No function matches the given name and argument types 'substr(Int32)'. You might need to add explicit type casts.+ Candidate functions:+ substr(string: String, start_pos: Int64, length: Int64)+ ");+ }}diff --git a/datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/nulls.rs b/datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/nulls.rsindex 435560721c..5b56b77e11 100644--- a/datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/nulls.rs+++ b/datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/nulls.rs@@ -206,7 +206,7 @@ pub fn set_nulls_dyn(input: &dyn Array, nulls: Option<NullBuffer>) -> Result<Arr}}_ => {- return not_impl_err!("Applying nulls {:?}", input.data_type());+ return not_impl_err!("Applying nulls {}", input.data_type());}};assert_eq!(input.len(), output.len());diff --git a/datafusion/optimizer/src/analyzer/type_coercion.rs b/datafusion/optimizer/src/analyzer/type_coercion.rsindex ed04aa4285..efc9984acb 100644--- a/datafusion/optimizer/src/analyzer/type_coercion.rs+++ b/datafusion/optimizer/src/analyzer/type_coercion.rs@@ -849,7 +849,7 @@ fn coerce_scalar_range_aware(// If type coercion fails, check if the largest type in family works:if let Some(largest_type) = get_widest_type_in_family(target_type) {coerce_scalar(largest_type, value).map_or_else(- |_| exec_err!("Cannot cast {value:?} to {target_type}"),+ |_| exec_err!("Cannot cast {value} to {target_type}"),|_| ScalarValue::try_from(target_type),)} else {diff --git a/datafusion/physical-plan/src/aggregates/topk/heap.rs b/datafusion/physical-plan/src/aggregates/topk/heap.rsindex 9f0b697cca..889fe04bf8 100644--- a/datafusion/physical-plan/src/aggregates/topk/heap.rs+++ b/datafusion/physical-plan/src/aggregates/topk/heap.rs@@ -216,7 +216,7 @@ fn extract_string_value<'a>(DataType::Utf8 => batch.as_string::<i32>().value(idx),DataType::LargeUtf8 => batch.as_string::<i64>().value(idx),DataType::Utf8View => batch.as_string_view().value(idx),- _ => unreachable!("Unsupported string type: {:?}", data_type),+ _ => unreachable!("Unsupported string type: {data_type}"),}}@@ -316,7 +316,7 @@ impl ArrowHeap for StringHeap {DataType::Utf8 => build_string_array!(StringBuilder),DataType::LargeUtf8 => build_string_array!(LargeStringBuilder),DataType::Utf8View => build_string_array!(StringViewBuilder),- _ => unreachable!("Unsupported string type: {:?}", self.data_type),+ _ => unreachable!("Unsupported string type: {}", self.data_type),};(arr, map_idxs)}diff --git a/datafusion/physical-plan/src/unnest.rs b/datafusion/physical-plan/src/unnest.rsindex 72faeb83c5..48de79b741 100644--- a/datafusion/physical-plan/src/unnest.rs+++ b/datafusion/physical-plan/src/unnest.rs@@ -426,9 +426,7 @@ fn flatten_struct_cols(Ok(struct_arr.columns().to_vec())}data_type => internal_err!(- "expecting column {} from input plan to be a struct, got {:?}",- idx,- data_type+ "expecting column {idx} from input plan to be a struct, got {data_type}"),},None => Ok(vec![Arc::clone(column_data)]),diff --git a/datafusion/sql/tests/sql_integration.rs b/datafusion/sql/tests/sql_integration.rsindex 444bdae73a..9570336e99 100644--- a/datafusion/sql/tests/sql_integration.rs+++ b/datafusion/sql/tests/sql_integration.rs@@ -4730,56 +4730,35 @@ fn test_custom_type_plan() -> Result<()> {Ok(())}-fn error_message_test(sql: &str, err_msg_starts_with: &str) {+fn error_message(sql: &str) -> String {let err = logical_plan(sql).expect_err("query should have failed");- assert!(- err.strip_backtrace().starts_with(err_msg_starts_with),- "Expected error to start with '{}', but got: '{}'",- err_msg_starts_with,- err.strip_backtrace(),- );+ err.strip_backtrace()}#[test]fn test_error_message_invalid_scalar_function_signature() {- error_message_test(- "select sqrt()",- "Error during planning: 'sqrt' does not support zero arguments",- );- error_message_test(- "select sqrt(1, 2)",- "Error during planning: Failed to coerce arguments",+ assert!(+ error_message("select sqrt()").starts_with(+ r"Error during planning: 'sqrt' does not support zero arguments"+ ));+ assert!(error_message("select sqrt(1, 2)").starts_with(r"Error during planning: Failed to coerce arguments to satisfy a call to 'sqrt' function: coercion from Int64, Int64 to the signature Exact(Int64) failed"));}#[test]fn test_error_message_invalid_aggregate_function_signature() {- error_message_test(- "select sum()",- "Error during planning: Execution error: Function 'sum' user-defined coercion failed with \"Execution error: sum function requires 1 argument, got 0\"",- );- // We keep two different prefixes because they clarify each other.- // It might be incorrect, and we should consider keeping only one.- error_message_test(- "select max(9, 3)",- "Error during planning: Execution error: Function 'max' user-defined coercion failed",- );+ assert!(error_message("select sum()").starts_with(r"Error during planning: Execution error: Function 'sum' user-defined coercion failed with: Execution error: sum function requires 1 argument, got 0"));+ assert!(error_message("select max(9, 3)").starts_with(r"Error during planning: Execution error: Function 'max' user-defined coercion failed with: Execution error: min/max was called with 2 arguments. It requires only 1"));}#[test]fn test_error_message_invalid_window_function_signature() {- error_message_test(- "select rank(1) over()",- "Error during planning: The function 'rank' expected zero argument but received 1",- );+ assert!(error_message("select rank(1) over()").starts_with(r"Error during planning: The function 'rank' expected zero argument but received 1"));}#[test]fn test_error_message_invalid_window_aggregate_function_signature() {- error_message_test(- "select sum() over()",- "Error during planning: Execution error: Function 'sum' user-defined coercion failed with \"Execution error: sum function requires 1 argument, got 0\"",- );+ assert!(error_message("select sum() over()").starts_with(r"Error during planning: Execution error: Function 'sum' user-defined coercion failed with: Execution error: sum function requires 1 argument, got 0"));}// Test issue: https://github.com/apache/datafusion/issues/14058diff --git a/datafusion/sqllogictest/test_files/array.slt b/datafusion/sqllogictest/test_files/array.sltindex 00d28d38d6..112351c5ef 100644--- a/datafusion/sqllogictest/test_files/array.slt+++ b/datafusion/sqllogictest/test_files/array.slt@@ -3470,7 +3470,7 @@ select array_concat([NULL, NULL], [NULL, NULL]);[NULL, NULL, NULL, NULL]# array_concat error-query error DataFusion error: Error during planning: Execution error: Function 'array_concat' user-defined coercion failed with "Error during planning: array_concat does not support type Int64"+query error DataFusion error: Error during planning: Execution error: Function 'array_concat' user-defined coercion failed with: Error during planning: array_concat does not support type Int64select array_concat(1, 2);# array_concat scalar function #1diff --git a/datafusion/sqllogictest/test_files/arrow_typeof.slt b/datafusion/sqllogictest/test_files/arrow_typeof.sltindex 0c69e8591c..e00909ad5f 100644--- a/datafusion/sqllogictest/test_files/arrow_typeof.slt+++ b/datafusion/sqllogictest/test_files/arrow_typeof.slt@@ -95,7 +95,7 @@ SELECT arrow_cast('1', 'Int16')query errorSELECT arrow_cast('1')-query error DataFusion error: Error during planning: Function 'arrow_cast' requires TypeSignatureClass::Native\(LogicalType\(Native\(String\), String\)\), but received Int64 \(DataType: Int64\)+query error DataFusion error: Error during planning: Function 'arrow_cast' requires String, but received Int64 \(DataType: Int64\)SELECT arrow_cast('1', 43)query error DataFusion error: Execution error: arrow_cast requires its second argument to be a non\-empty constant stringdiff --git a/datafusion/sqllogictest/test_files/binary.slt b/datafusion/sqllogictest/test_files/binary.sltindex c4a21deeff..54ac51d9e7 100644--- a/datafusion/sqllogictest/test_files/binary.slt+++ b/datafusion/sqllogictest/test_files/binary.slt@@ -313,7 +313,7 @@ Bar Bar Bar BarFooBar fooBar FooBar fooBar# show helpful error msg when Binary type is used with string functions-query error DataFusion error: Error during planning: Function 'split_part' requires TypeSignatureClass::Native\(LogicalType\(Native\(String\), String\)\), but received Binary \(DataType: Binary\)\.\n\nHint: Binary types are not automatically coerced to String\. Use CAST\(column AS VARCHAR\) to convert Binary data to String\.+query error DataFusion error: Error during planning: Function 'split_part' requires String, but received Binary \(DataType: Binary\)\.\n\nHint: Binary types are not automatically coerced to String\. Use CAST\(column AS VARCHAR\) to convert Binary data to String\.SELECT split_part(binary, '~', 2) FROM t WHERE binary IS NOT NULL LIMIT 1;# ensure the suggested CAST workaround worksdiff --git a/datafusion/sqllogictest/test_files/datetime/timestamps.slt b/datafusion/sqllogictest/test_files/datetime/timestamps.sltindex 9526ccebfd..78889230fd 100644--- a/datafusion/sqllogictest/test_files/datetime/timestamps.slt+++ b/datafusion/sqllogictest/test_files/datetime/timestamps.slt@@ -3076,7 +3076,7 @@ NULLquery error DataFusion error: Error during planning: Function 'make_date' expects 3 arguments but received 1select make_date(1);-query error DataFusion error: Error during planning: Function 'make_date' requires TypeSignatureClass::Native\(LogicalType\(Native\(Int32\), Int32\)\), but received Interval\(MonthDayNano\) \(DataType: Interval\(MonthDayNano\)\)+query error DataFusion error: Error during planning: Function 'make_date' requires Int32, but received Interval\(MonthDayNano\) \(DataType: Interval\(MonthDayNano\)\).select make_date(interval '1 day', '2001-05-21'::timestamp, '2001-05-21'::timestamp);##########@@ -3349,7 +3349,7 @@ select make_time(22, '', 27);query error Cannot cast string '' to value of Int32 typeselect make_time(22, 1, '');-query error DataFusion error: Error during planning: Function 'make_time' requires TypeSignatureClass::Native\(LogicalType\(Native\(Int32\), Int32\)\), but received Float64 \(DataType: Float64\)+query error DataFusion error: Error during planning: Function 'make_time' requires Int32, but received Float64 \(DataType: Float64\)select make_time(arrow_cast(22, 'Float64'), 1, '');##########@@ -3964,7 +3964,7 @@ statement errorselect to_local_time('2024-04-01T00:00:20Z'::timestamp, 'some string');# invalid argument data type-statement error DataFusion error: Error during planning: Function 'to_local_time' requires TypeSignatureClass::Timestamp, but received String \(DataType: Utf8\)+statement error DataFusion error: Error during planning: Function 'to_local_time' requires Timestamp, but received String \(DataType: Utf8\)select to_local_time('2024-04-01T00:00:20Z');# invalid timezonediff --git a/datafusion/sqllogictest/test_files/encoding.slt b/datafusion/sqllogictest/test_files/encoding.sltindex b04d506182..c68d59819e 100644--- a/datafusion/sqllogictest/test_files/encoding.slt+++ b/datafusion/sqllogictest/test_files/encoding.slt@@ -75,10 +75,10 @@ CREATE TABLE test(;# errors-query error DataFusion error: Error during planning: Function 'encode' requires TypeSignatureClass::Binary, but received Int64 \(DataType: Int64\)+query error DataFusion error: Error during planning: Function 'encode' requires Binary, but received Int64 \(DataType: Int64\)select encode(12, 'hex');-query error DataFusion error: Error during planning: Function 'decode' requires TypeSignatureClass::Binary, but received Int64 \(DataType: Int64\)+query error DataFusion error: Error during planning: Function 'decode' requires Binary, but received Int64 \(DataType: Int64\)select decode(12, 'hex');query error DataFusion error: Error during planning: There is no built\-in encoding named 'non_encoding', currently supported encodings are: base64, base64pad, hex@@ -93,7 +93,7 @@ select decode('', null) from test;query error DataFusion error: This feature is not implemented: Encoding must be a scalar; array specified encoding is not yet supportedselect decode('', hex_field) from test;-query error DataFusion error: Error during planning: Function 'to_hex' requires TypeSignatureClass::Integer, but received String \(DataType: Utf8View\)+query error DataFusion error: Error during planning: Function 'to_hex' requires Integer, but received String \(DataType: Utf8View\)select to_hex(hex_field) from test;query error DataFusion error: Execution error: Failed to decode value using base64diff --git a/datafusion/sqllogictest/test_files/expr.slt b/datafusion/sqllogictest/test_files/expr.sltindex 6d19d1436e..a6341bc686 100644--- a/datafusion/sqllogictest/test_files/expr.slt+++ b/datafusion/sqllogictest/test_files/expr.slt@@ -618,7 +618,7 @@ select repeat('-1.2', arrow_cast(3, 'Int32'));-----1.2-1.2-1.2-query error DataFusion error: Error during planning: Function 'repeat' requires TypeSignatureClass::Native\(LogicalType\(Native\(Int64\), Int64\)\), but received Float64 \(DataType: Float64\)+query error DataFusion error: Error during planning: Function 'repeat' requires Int64, but received Float64 \(DataType: Float64\)select repeat('-1.2', 3.2);query Tdiff --git a/datafusion/sqllogictest/test_files/functions.slt b/datafusion/sqllogictest/test_files/functions.sltindex 5a43d18e23..fa852e98ac 100644--- a/datafusion/sqllogictest/test_files/functions.slt+++ b/datafusion/sqllogictest/test_files/functions.slt@@ -887,7 +887,7 @@ SELECT greatest(-1, 1, 2.3, 123456789, 3 + 5, -(-4), abs(-9.0))123456789-query error Function 'greatest' user-defined coercion failed with "Error during planning: greatest was called without any arguments. It requires at least 1."+query error Function 'greatest' user-defined coercion failed with: Error during planning: greatest was called without any arguments. It requires at least 1.SELECT greatest()query I@@ -1085,7 +1085,7 @@ SELECT least(-1, 1, 2.3, 123456789, 3 + 5, -(-4), abs(-9.0))-1-query error Function 'least' user-defined coercion failed with "Error during planning: least was called without any arguments. It requires at least 1."+query error Function 'least' user-defined coercion failed with: Error during planning: least was called without any arguments. It requires at least 1.SELECT least()query Idiff --git a/datafusion/sqllogictest/test_files/math.slt b/datafusion/sqllogictest/test_files/math.sltindex 2227466fdf..d571fcd947 100644--- a/datafusion/sqllogictest/test_files/math.slt+++ b/datafusion/sqllogictest/test_files/math.slt@@ -158,15 +158,15 @@ statement errorSELECT abs(1, 2);# abs: unsupported argument type-query error DataFusion error: Error during planning: Function 'abs' expects NativeType::Numeric but received NativeType::String+query error DataFusion error: Error during planning: Function 'abs' expects Numeric but received StringSELECT abs('foo');# abs: numeric string# TODO: In Postgres, '-1.2' is unknown type and interpreted to float8 so they don't fail on this query-query error DataFusion error: Error during planning: Function 'abs' expects NativeType::Numeric but received NativeType::String+query error DataFusion error: Error during planning: Function 'abs' expects Numeric but received Stringselect abs('-1.2');-query error DataFusion error: Error during planning: Function 'abs' expects NativeType::Numeric but received NativeType::String+query error DataFusion error: Error during planning: Function 'abs' expects Numeric but received Stringselect abs(arrow_cast('-1.2', 'Utf8'));statement okdiff --git a/datafusion/sqllogictest/test_files/scalar.slt b/datafusion/sqllogictest/test_files/scalar.sltindex 681540a29d..e91ec1cb84 100644--- a/datafusion/sqllogictest/test_files/scalar.slt+++ b/datafusion/sqllogictest/test_files/scalar.slt@@ -2137,7 +2137,7 @@ select position('' in '')----1-query error DataFusion error: Error during planning: Function 'strpos' requires TypeSignatureClass::Native\(LogicalType\(Native\(String\), String\)\), but received Int64 \(DataType: Int64\)+query error DataFusion error: Error during planning: Function 'strpos' requires String, but received Int64 \(DataType: Int64\).select position(1 in 1)query Idiff --git a/datafusion/sqllogictest/test_files/spark/datetime/unix.slt b/datafusion/sqllogictest/test_files/spark/datetime/unix.sltindex d7441f487d..9dd39acd7f 100644--- a/datafusion/sqllogictest/test_files/spark/datetime/unix.slt+++ b/datafusion/sqllogictest/test_files/spark/datetime/unix.slt@@ -38,7 +38,7 @@ SELECT unix_date(NULL::date);----NULL-query error Function 'unix_date' requires TypeSignatureClass::Native\(LogicalType\(Native\(Date\), Date\)\), but received String \(DataType: Utf8View\)+query error Function 'unix_date' requires Date, but received String \(DataType: Utf8View\)SELECT unix_date('1970-01-02'::string);# Unix Micro Tests@@ -68,7 +68,7 @@ SELECT unix_micros(NULL::timestamp);----NULL-query error Function 'unix_micros' requires TypeSignatureClass::Timestamp, but received String \(DataType: Utf8View\)+query error Function 'unix_micros' requires Timestamp, but received String \(DataType: Utf8View\)SELECT unix_micros('1970-01-01 00:00:01Z'::string);@@ -99,7 +99,7 @@ SELECT unix_millis(NULL::timestamp);----NULL-query error Function 'unix_millis' requires TypeSignatureClass::Timestamp, but received String \(DataType: Utf8View\)+query error Function 'unix_millis' requires Timestamp, but received String \(DataType: Utf8View\)SELECT unix_millis('1970-01-01 00:00:01Z'::string);@@ -130,5 +130,5 @@ SELECT unix_seconds(NULL::timestamp);----NULL-query error Function 'unix_seconds' requires TypeSignatureClass::Timestamp, but received String \(DataType: Utf8View\)+query error Function 'unix_seconds' requires Timestamp, but received String \(DataType: Utf8View\)SELECT unix_seconds('1970-01-01 00:00:01Z'::string);diff --git a/datafusion/sqllogictest/test_files/spark/string/base64.slt b/datafusion/sqllogictest/test_files/spark/string/base64.sltindex 03b488de0e..dbd266f65a 100644--- a/datafusion/sqllogictest/test_files/spark/string/base64.slt+++ b/datafusion/sqllogictest/test_files/spark/string/base64.slt@@ -58,7 +58,7 @@ U3BhcmsgU1E=U3BhcmsgUw==NULL-query error Function 'base64' requires TypeSignatureClass::Binary, but received Int32 \(DataType: Int32\)+query error Error during planning: Function 'base64' requires Binary, but received Int32 \(DataType: Int32\)SELECT base64(12::integer);@@ -111,5 +111,5 @@ SELECT unbase64('123'::string);query error Failed to decode value using base64SELECT unbase64('123'::bytea);-query error Function 'unbase64' requires TypeSignatureClass::Binary, but received Int32 \(DataType: Int32\)+query error Error during planning: Function 'unbase64' requires Binary, but received Int32 \(DataType: Int32\)SELECT unbase64(12::integer);diff --git a/datafusion/sqllogictest/test_files/window.slt b/datafusion/sqllogictest/test_files/window.sltindex c3e6f39adb..62296c5d87 100644--- a/datafusion/sqllogictest/test_files/window.slt+++ b/datafusion/sqllogictest/test_files/window.slt@@ -2580,7 +2580,7 @@ statement okset datafusion.optimizer.skip_failed_rules = true# Error is returned from the physical plan.-query error Cannot cast Utf8\("1 DAY"\) to Int8+query error Cannot cast 1 DAY to Int8SELECTCOUNT(c1) OVER (ORDER BY c2 RANGE BETWEEN '1 DAY' PRECEDING AND '2 DAY' FOLLOWING)FROM aggregate_test_100;@@ -2589,7 +2589,7 @@ statement okset datafusion.optimizer.skip_failed_rules = false# Error is returned from the logical plan.-query error Cannot cast Utf8\("1 DAY"\) to Int8+query error Cannot cast 1 DAY to Int8SELECTCOUNT(c1) OVER (ORDER BY c2 RANGE BETWEEN '1 DAY' PRECEDING AND '2 DAY' FOLLOWING)FROM aggregate_test_100;