From ad60ffcfca201808215dc05ac5c8c68001ed6051 Mon Sep 17 00:00:00 2001 From: Bruce Ritchie Date: Thu, 6 Feb 2025 11:15:41 -0500 Subject: [PATCH] Improve error messages to include the function name. (#14511) * Improve error messages to include the function name. * Apply suggestions from code review Words better this PR has. Co-authored-by: Andrew Lamb * Updates and fixes from PR review. * Updated error messages to highlight the function name. --------- Co-authored-by: Andrew Lamb --- .../expr/src/type_coercion/functions.rs | 190 +++++++++++------- .../optimizer/src/analyzer/type_coercion.rs | 4 +- datafusion/sql/tests/sql_integration.rs | 10 +- .../sqllogictest/test_files/aggregate.slt | 12 +- datafusion/sqllogictest/test_files/array.slt | 4 +- datafusion/sqllogictest/test_files/errors.slt | 6 +- datafusion/sqllogictest/test_files/expr.slt | 2 +- .../sqllogictest/test_files/functions.slt | 4 +- datafusion/sqllogictest/test_files/math.slt | 6 +- datafusion/sqllogictest/test_files/scalar.slt | 2 +- 10 files changed, 141 insertions(+), 99 deletions(-) diff --git a/datafusion/expr/src/type_coercion/functions.rs b/datafusion/expr/src/type_coercion/functions.rs index 8cebf7c3db12..0f9dbec722c2 100644 --- a/datafusion/expr/src/type_coercion/functions.rs +++ b/datafusion/expr/src/type_coercion/functions.rs @@ -57,9 +57,9 @@ pub fn data_types_with_scalar_udf( return Ok(vec![]); } else if type_signature.used_to_support_zero_arguments() { // Special error to help during upgrade: https://github.com/apache/datafusion/issues/13763 - return plan_err!("{} does not support zero arguments. Use TypeSignature::Nullary for zero arguments.", func.name()); + return plan_err!("'{}' does not support zero arguments. Use TypeSignature::Nullary for zero arguments", func.name()); } else { - return plan_err!("{} does not support zero arguments.", func.name()); + return plan_err!("'{}' does not support zero arguments", func.name()); } } @@ -95,9 +95,9 @@ pub fn data_types_with_aggregate_udf( return Ok(vec![]); } else if type_signature.used_to_support_zero_arguments() { // Special error to help during upgrade: https://github.com/apache/datafusion/issues/13763 - return plan_err!("{} does not support zero arguments. Use TypeSignature::Nullary for zero arguments.", func.name()); + return plan_err!("'{}' does not support zero arguments. Use TypeSignature::Nullary for zero arguments", func.name()); } else { - return plan_err!("{} does not support zero arguments.", func.name()); + return plan_err!("'{}' does not support zero arguments", func.name()); } } @@ -132,9 +132,9 @@ pub fn data_types_with_window_udf( return Ok(vec![]); } else if type_signature.used_to_support_zero_arguments() { // Special error to help during upgrade: https://github.com/apache/datafusion/issues/13763 - return plan_err!("{} does not support zero arguments. Use TypeSignature::Nullary for zero arguments.", func.name()); + return plan_err!("'{}' does not support zero arguments. Use TypeSignature::Nullary for zero arguments", func.name()); } else { - return plan_err!("{} does not support zero arguments.", func.name()); + return plan_err!("'{}' does not support zero arguments", func.name()); } } @@ -170,18 +170,19 @@ 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/13763 return plan_err!( - "signature {:?} does not support zero arguments. Use TypeSignature::Nullary for zero arguments.", - type_signature + "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!( - "signature {:?} does not support zero arguments.", - type_signature + "Function '{}' has signature {type_signature:?} which does not support zero arguments", + function_name.as_ref() ); } } - let valid_types = get_valid_types(type_signature, current_types)?; + let valid_types = + get_valid_types(function_name.as_ref(), type_signature, current_types)?; if valid_types .iter() .any(|data_type| data_type == current_types) @@ -189,7 +190,12 @@ pub fn data_types( return Ok(current_types.to_vec()); } - try_coerce_types(function_name, valid_types, current_types, type_signature) + try_coerce_types( + function_name.as_ref(), + valid_types, + current_types, + type_signature, + ) } fn is_well_supported_signature(type_signature: &TypeSignature) -> bool { @@ -210,7 +216,7 @@ fn is_well_supported_signature(type_signature: &TypeSignature) -> bool { } fn try_coerce_types( - function_name: impl AsRef, + function_name: &str, valid_types: Vec>, current_types: &[DataType], type_signature: &TypeSignature, @@ -242,10 +248,7 @@ fn try_coerce_types( // none possible -> Error plan_err!( - "Failed to coerce arguments to satisfy a call to {} function: coercion from {:?} to the signature {:?} failed.", - function_name.as_ref(), - current_types, - type_signature + "Failed to coerce arguments to satisfy a call to '{function_name}' function: coercion from {current_types:?} to the signature {type_signature:?} failed" ) } @@ -257,7 +260,10 @@ fn get_valid_types_with_scalar_udf( match signature { TypeSignature::UserDefined => match func.coerce_types(current_types) { Ok(coerced_types) => Ok(vec![coerced_types]), - Err(e) => exec_err!("User-defined coercion failed with {:?}", e), + Err(e) => exec_err!( + "Function '{}' user-defined coercion failed with {e:?}", + func.name() + ), }, TypeSignature::OneOf(signatures) => { let mut res = vec![]; @@ -276,14 +282,15 @@ fn get_valid_types_with_scalar_udf( // Every signature failed, return the joined error if res.is_empty() { internal_err!( - "Failed to match any signature, errors: {}", + "Function '{}' failed to match any signature, errors: {}", + func.name(), errors.join(",") ) } else { Ok(res) } } - _ => get_valid_types(signature, current_types), + _ => get_valid_types(func.name(), signature, current_types), } } @@ -295,7 +302,12 @@ fn get_valid_types_with_aggregate_udf( let valid_types = match signature { TypeSignature::UserDefined => match func.coerce_types(current_types) { Ok(coerced_types) => vec![coerced_types], - Err(e) => return exec_err!("User-defined coercion failed with {:?}", e), + Err(e) => { + return exec_err!( + "Function '{}' user-defined coercion failed with {e:?}", + func.name() + ) + } }, TypeSignature::OneOf(signatures) => signatures .iter() @@ -304,7 +316,7 @@ fn get_valid_types_with_aggregate_udf( }) .flatten() .collect::>(), - _ => get_valid_types(signature, current_types)?, + _ => get_valid_types(func.name(), signature, current_types)?, }; Ok(valid_types) @@ -318,14 +330,19 @@ fn get_valid_types_with_window_udf( let valid_types = match signature { TypeSignature::UserDefined => match func.coerce_types(current_types) { Ok(coerced_types) => vec![coerced_types], - Err(e) => return exec_err!("User-defined coercion failed with {:?}", e), + Err(e) => { + return exec_err!( + "Function '{}' user-defined coercion failed with {e:?}", + func.name() + ) + } }, TypeSignature::OneOf(signatures) => signatures .iter() .filter_map(|t| get_valid_types_with_window_udf(t, current_types, func).ok()) .flatten() .collect::>(), - _ => get_valid_types(signature, current_types)?, + _ => get_valid_types(func.name(), signature, current_types)?, }; Ok(valid_types) @@ -333,10 +350,12 @@ fn get_valid_types_with_window_udf( /// Returns a Vec of all possible valid argument types for the given signature. fn get_valid_types( + function_name: &str, signature: &TypeSignature, current_types: &[DataType], ) -> Result>> { fn array_element_and_optional_index( + function_name: &str, current_types: &[DataType], ) -> Result>> { // make sure there's 2 or 3 arguments @@ -345,7 +364,8 @@ fn get_valid_types( } let first_two_types = ¤t_types[0..2]; - let mut valid_types = array_append_or_prepend_valid_types(first_two_types, true)?; + let mut valid_types = + array_append_or_prepend_valid_types(function_name, first_two_types, true)?; // Early return if there are only 2 arguments if current_types.len() == 2 { @@ -367,6 +387,7 @@ fn get_valid_types( } fn array_append_or_prepend_valid_types( + function_name: &str, current_types: &[DataType], is_append: bool, ) -> Result>> { @@ -393,7 +414,7 @@ fn get_valid_types( let new_base_type = new_base_type.ok_or_else(|| { internal_datafusion_err!( - "Coercion from {array_base_type:?} to {elem_base_type:?} not supported." + "Function '{function_name}' does not support coercion from {array_base_type:?} to {elem_base_type:?}" ) })?; @@ -437,10 +458,14 @@ fn get_valid_types( } } - fn function_length_check(length: usize, expected_length: usize) -> Result<()> { + fn function_length_check( + function_name: &str, + length: usize, + expected_length: usize, + ) -> Result<()> { if length != expected_length { return plan_err!( - "The signature expected {expected_length} arguments but received {length}" + "Function '{function_name}' expects {expected_length} arguments but received {length}" ); } Ok(()) @@ -452,7 +477,7 @@ fn get_valid_types( .map(|valid_type| current_types.iter().map(|_| valid_type.clone()).collect()) .collect(), TypeSignature::String(number) => { - function_length_check(current_types.len(), *number)?; + function_length_check(function_name, current_types.len(), *number)?; let mut new_types = Vec::with_capacity(current_types.len()); for data_type in current_types.iter() { @@ -464,30 +489,31 @@ fn get_valid_types( new_types.push(DataType::Utf8); } else { return plan_err!( - "The signature expected NativeType::String but received {logical_data_type}" + "Function '{function_name}' expects NativeType::String but received {logical_data_type}" ); } } // Find the common string type for the given types fn find_common_type( + function_name: &str, lhs_type: &DataType, rhs_type: &DataType, ) -> Result { match (lhs_type, rhs_type) { (DataType::Dictionary(_, lhs), DataType::Dictionary(_, rhs)) => { - find_common_type(lhs, rhs) + find_common_type(function_name, lhs, rhs) } (DataType::Dictionary(_, v), other) - | (other, DataType::Dictionary(_, v)) => find_common_type(v, other), + | (other, DataType::Dictionary(_, v)) => { + find_common_type(function_name, v, other) + } _ => { if let Some(coerced_type) = string_coercion(lhs_type, rhs_type) { Ok(coerced_type) } else { plan_err!( - "{} and {} are not coercible to a common string type", - lhs_type, - rhs_type + "Function '{function_name}' could not coerce {lhs_type} and {rhs_type} to a common string type" ) } } @@ -497,7 +523,7 @@ fn get_valid_types( // Length checked above, safe to unwrap let mut coerced_type = new_types.first().unwrap().to_owned(); for t in new_types.iter().skip(1) { - coerced_type = find_common_type(&coerced_type, t)?; + coerced_type = find_common_type(function_name, &coerced_type, t)?; } fn base_type_or_default_type(data_type: &DataType) -> DataType { @@ -511,7 +537,7 @@ fn get_valid_types( vec![vec![base_type_or_default_type(&coerced_type); *number]] } TypeSignature::Numeric(number) => { - function_length_check(current_types.len(), *number)?; + function_length_check(function_name, current_types.len(), *number)?; // Find common numeric type among given types except string let mut valid_type = current_types.first().unwrap().to_owned(); @@ -523,7 +549,7 @@ fn get_valid_types( if !logical_data_type.is_numeric() { return plan_err!( - "The signature expected NativeType::Numeric but received {logical_data_type}" + "Function '{function_name}' expects NativeType::Numeric but received {logical_data_type}" ); } @@ -531,9 +557,7 @@ fn get_valid_types( valid_type = coerced_type; } else { return plan_err!( - "{} and {} are not coercible to a common numeric type", - valid_type, - t + "For function '{function_name}' {valid_type} and {t} are not coercible to a common numeric type" ); } } @@ -546,20 +570,20 @@ fn get_valid_types( valid_type = DataType::Float64; } else if !logical_data_type.is_numeric() { return plan_err!( - "The signature expected NativeType::Numeric but received {logical_data_type}" + "Function '{function_name}' expects NativeType::Numeric but received {logical_data_type}" ); } vec![vec![valid_type; *number]] } TypeSignature::Comparable(num) => { - function_length_check(current_types.len(), *num)?; + function_length_check(function_name, current_types.len(), *num)?; let mut target_type = current_types[0].to_owned(); for data_type in current_types.iter().skip(1) { if let Some(dt) = comparison_coercion_numeric(&target_type, data_type) { target_type = dt; } else { - return plan_err!("{target_type} and {data_type} is not comparable"); + return plan_err!("For function '{function_name}' {target_type} and {data_type} is not comparable"); } } // Convert null to String type. @@ -570,12 +594,17 @@ fn get_valid_types( } } TypeSignature::Coercible(target_types) => { - function_length_check(current_types.len(), target_types.len())?; + function_length_check( + function_name, + current_types.len(), + target_types.len(), + )?; // Aim to keep this logic as SIMPLE as possible! // Make sure the corresponding test is covered // If this function becomes COMPLEX, create another new signature! fn can_coerce_to( + function_name: &str, current_type: &DataType, target_type_class: &TypeSignatureClass, ) -> Result { @@ -597,9 +626,7 @@ fn get_valid_types( } internal_err!( - "Expect {} but received {}", - target_type_class, - current_type + "Function '{function_name}' expects {target_type_class} but received {current_type}" ) } // Not consistent with Postgres and DuckDB but to avoid regression we implicit cast string to timestamp @@ -624,7 +651,7 @@ fn get_valid_types( Ok(current_type.to_owned()) } _ => { - not_impl_err!("Got logical_type: {logical_type} with target_type_class: {target_type_class}") + not_impl_err!("Function '{function_name}' got logical_type: {logical_type} with target_type_class: {target_type_class}") } } } @@ -633,7 +660,7 @@ fn get_valid_types( for (current_type, target_type_class) in current_types.iter().zip(target_types.iter()) { - let target_type = can_coerce_to(current_type, target_type_class)?; + let target_type = can_coerce_to(function_name, current_type, target_type_class)?; new_types.push(target_type); } @@ -641,7 +668,7 @@ fn get_valid_types( } TypeSignature::Uniform(number, valid_types) => { if *number == 0 { - return plan_err!("The function expected at least one argument"); + return plan_err!("The function '{function_name}' expected at least one argument"); } valid_types @@ -651,13 +678,13 @@ fn get_valid_types( } TypeSignature::UserDefined => { return internal_err!( - "User-defined signature should be handled by function-specific coerce_types." - ) + "Function '{function_name}' user-defined signature should be handled by function-specific coerce_types" + ) } TypeSignature::VariadicAny => { if current_types.is_empty() { return plan_err!( - "The function expected at least one argument but received 0" + "Function '{function_name}' expected at least one argument but received 0" ); } vec![current_types.to_vec()] @@ -666,10 +693,10 @@ fn get_valid_types( TypeSignature::ArraySignature(ref function_signature) => match function_signature { ArrayFunctionSignature::ArrayAndElement => { - array_append_or_prepend_valid_types(current_types, true)? + array_append_or_prepend_valid_types(function_name, current_types, true)? } ArrayFunctionSignature::ElementAndArray => { - array_append_or_prepend_valid_types(current_types, false)? + array_append_or_prepend_valid_types(function_name, current_types, false)? } ArrayFunctionSignature::ArrayAndIndexes(count) => { if current_types.len() != count.get() + 1 { @@ -688,7 +715,7 @@ fn get_valid_types( ) } ArrayFunctionSignature::ArrayAndElementAndOptionalIndex => { - array_element_and_optional_index(current_types)? + array_element_and_optional_index(function_name, current_types)? } ArrayFunctionSignature::Array => { if current_types.len() != 1 { @@ -719,7 +746,7 @@ fn get_valid_types( TypeSignature::Nullary => { if !current_types.is_empty() { return plan_err!( - "The function expected zero argument but received {}", + "The function '{function_name}' expected zero argument but received {}", current_types.len() ); } @@ -728,14 +755,13 @@ fn get_valid_types( TypeSignature::Any(number) => { if current_types.is_empty() { return plan_err!( - "The function expected at least one argument but received 0" + "The function '{function_name}' expected at least one argument but received 0" ); } if current_types.len() != *number { return plan_err!( - "The function expected {} arguments but received {}", - number, + "The function '{function_name}' expected {number} arguments but received {}", current_types.len() ); } @@ -743,7 +769,7 @@ fn get_valid_types( } TypeSignature::OneOf(types) => types .iter() - .filter_map(|t| get_valid_types(t, current_types).ok()) + .filter_map(|t| get_valid_types(function_name, t, current_types).ok()) .flatten() .collect::>(), }; @@ -1011,8 +1037,10 @@ mod tests { #[test] fn test_get_valid_types_numeric() -> Result<()> { let get_valid_types_flatten = - |signature: &TypeSignature, current_types: &[DataType]| { - get_valid_types(signature, current_types) + |function_name: &str, + signature: &TypeSignature, + current_types: &[DataType]| { + get_valid_types(function_name, signature, current_types) .unwrap() .into_iter() .flatten() @@ -1020,11 +1048,16 @@ mod tests { }; // Trivial case. - let got = get_valid_types_flatten(&TypeSignature::Numeric(1), &[DataType::Int32]); + let got = get_valid_types_flatten( + "test", + &TypeSignature::Numeric(1), + &[DataType::Int32], + ); assert_eq!(got, [DataType::Int32]); // Args are coerced into a common numeric type. let got = get_valid_types_flatten( + "test", &TypeSignature::Numeric(2), &[DataType::Int32, DataType::Int64], ); @@ -1032,6 +1065,7 @@ mod tests { // Args are coerced into a common numeric type, specifically, int would be coerced to float. let got = get_valid_types_flatten( + "test", &TypeSignature::Numeric(3), &[DataType::Int32, DataType::Int64, DataType::Float64], ); @@ -1042,28 +1076,34 @@ mod tests { // Cannot coerce args to a common numeric type. let got = get_valid_types( + "test", &TypeSignature::Numeric(2), &[DataType::Int32, DataType::Utf8], ) .unwrap_err(); assert_contains!( got.to_string(), - "The signature expected NativeType::Numeric but received NativeType::String" + "Function 'test' expects NativeType::Numeric but received NativeType::String" ); // Fallbacks to float64 if the arg is of type null. - let got = get_valid_types_flatten(&TypeSignature::Numeric(1), &[DataType::Null]); + let got = get_valid_types_flatten( + "test", + &TypeSignature::Numeric(1), + &[DataType::Null], + ); assert_eq!(got, [DataType::Float64]); // Rejects non-numeric arg. let got = get_valid_types( + "test", &TypeSignature::Numeric(1), &[DataType::Timestamp(TimeUnit::Second, None)], ) .unwrap_err(); assert_contains!( got.to_string(), - "The signature expected NativeType::Numeric but received NativeType::Timestamp(Second, None)" + "Function 'test' expects NativeType::Numeric but received NativeType::Timestamp(Second, None)" ); Ok(()) @@ -1075,18 +1115,19 @@ mod tests { TypeSignature::OneOf(vec![TypeSignature::Any(1), TypeSignature::Any(2)]); let invalid_types = get_valid_types( + "test", &signature, &[DataType::Int32, DataType::Int32, DataType::Int32], )?; assert_eq!(invalid_types.len(), 0); let args = vec![DataType::Int32, DataType::Int32]; - let valid_types = get_valid_types(&signature, &args)?; + let valid_types = get_valid_types("test", &signature, &args)?; assert_eq!(valid_types.len(), 1); assert_eq!(valid_types[0], args); let args = vec![DataType::Int32]; - let valid_types = get_valid_types(&signature, &args)?; + let valid_types = get_valid_types("test", &signature, &args)?; assert_eq!(valid_types.len(), 1); assert_eq!(valid_types[0], args); @@ -1097,20 +1138,21 @@ mod tests { fn test_get_valid_types_length_check() -> Result<()> { let signature = TypeSignature::Numeric(1); - let err = get_valid_types(&signature, &[]).unwrap_err(); + let err = get_valid_types("test", &signature, &[]).unwrap_err(); assert_contains!( err.to_string(), - "The signature expected 1 arguments but received 0" + "Function 'test' expects 1 arguments but received 0" ); let err = get_valid_types( + "test", &signature, &[DataType::Int32, DataType::Int32, DataType::Int32], ) .unwrap_err(); assert_contains!( err.to_string(), - "The signature expected 1 arguments but received 3" + "Function 'test' expects 1 arguments but received 3" ); Ok(()) @@ -1131,7 +1173,7 @@ mod tests { Volatility::Stable, ); - let coerced_data_types = data_types("test", ¤t_types, &signature).unwrap(); + let coerced_data_types = data_types("test", ¤t_types, &signature)?; assert_eq!(coerced_data_types, current_types); // make sure it can't coerce to a different size diff --git a/datafusion/optimizer/src/analyzer/type_coercion.rs b/datafusion/optimizer/src/analyzer/type_coercion.rs index 5097ff37643d..85fc9b31bcdd 100644 --- a/datafusion/optimizer/src/analyzer/type_coercion.rs +++ b/datafusion/optimizer/src/analyzer/type_coercion.rs @@ -1372,7 +1372,7 @@ mod test { let err = Projection::try_new(vec![udaf], empty).err().unwrap(); assert!( - err.strip_backtrace().starts_with("Error during planning: Failed to coerce arguments to satisfy a call to MY_AVG function: coercion from [Utf8] to the signature Uniform(1, [Float64]) failed") + err.strip_backtrace().starts_with("Error during planning: Failed to coerce arguments to satisfy a call to 'MY_AVG' function: coercion from [Utf8] to the signature Uniform(1, [Float64]) failed") ); Ok(()) } @@ -1422,7 +1422,7 @@ mod test { .err() .unwrap() .strip_backtrace(); - assert!(err.starts_with("Error during planning: Failed to coerce arguments to satisfy a call to avg function: coercion from [Utf8] to the signature Uniform(1, [Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Float32, Float64]) failed.")); + assert!(err.starts_with("Error during planning: Failed to coerce arguments to satisfy a call to 'avg' function: coercion from [Utf8] to the signature Uniform(1, [Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Float32, Float64]) failed")); Ok(()) } diff --git a/datafusion/sql/tests/sql_integration.rs b/datafusion/sql/tests/sql_integration.rs index 6a0db3888f83..21b6bf09fac7 100644 --- a/datafusion/sql/tests/sql_integration.rs +++ b/datafusion/sql/tests/sql_integration.rs @@ -4518,7 +4518,7 @@ fn error_message_test(sql: &str, err_msg_starts_with: &str) { fn test_error_message_invalid_scalar_function_signature() { error_message_test( "select sqrt()", - "Error during planning: sqrt does not support zero arguments", + "Error during planning: 'sqrt' does not support zero arguments", ); error_message_test( "select sqrt(1, 2)", @@ -4530,13 +4530,13 @@ fn test_error_message_invalid_scalar_function_signature() { fn test_error_message_invalid_aggregate_function_signature() { error_message_test( "select sum()", - "Error during planning: sum does not support zero arguments", + "Error during planning: 'sum' does not support zero arguments", ); // 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: User-defined coercion failed", + "Error during planning: Execution error: Function 'max' user-defined coercion failed", ); } @@ -4544,7 +4544,7 @@ fn test_error_message_invalid_aggregate_function_signature() { fn test_error_message_invalid_window_function_signature() { error_message_test( "select rank(1) over()", - "Error during planning: The function expected zero argument but received 1", + "Error during planning: The function 'rank' expected zero argument but received 1", ); } @@ -4552,7 +4552,7 @@ fn test_error_message_invalid_window_function_signature() { fn test_error_message_invalid_window_aggregate_function_signature() { error_message_test( "select sum() over()", - "Error during planning: sum does not support zero arguments", + "Error during planning: 'sum' does not support zero arguments", ); } diff --git a/datafusion/sqllogictest/test_files/aggregate.slt b/datafusion/sqllogictest/test_files/aggregate.slt index bb2ddf0da4d4..9d7ece1edd6e 100644 --- a/datafusion/sqllogictest/test_files/aggregate.slt +++ b/datafusion/sqllogictest/test_files/aggregate.slt @@ -132,26 +132,26 @@ statement error DataFusion error: Schema error: Schema contains duplicate unqual SELECT approx_distinct(c9) count_c9, approx_distinct(cast(c9 as varchar)) count_c9_str FROM aggregate_test_100 # csv_query_approx_percentile_cont_with_weight -statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to approx_percentile_cont_with_weight function: coercion from \[Utf8, Int8, Float64\] to the signature OneOf(.*) failed(.|\n)* +statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to 'approx_percentile_cont_with_weight' function: coercion from \[Utf8, Int8, Float64\] to the signature OneOf(.*) failed(.|\n)* SELECT approx_percentile_cont_with_weight(c1, c2, 0.95) FROM aggregate_test_100 -statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to approx_percentile_cont_with_weight function: coercion from \[Int16, Utf8, Float64\] to the signature OneOf(.*) failed(.|\n)* +statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to 'approx_percentile_cont_with_weight' function: coercion from \[Int16, Utf8, Float64\] to the signature OneOf(.*) failed(.|\n)* SELECT approx_percentile_cont_with_weight(c3, c1, 0.95) FROM aggregate_test_100 -statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to approx_percentile_cont_with_weight function: coercion from \[Int16, Int8, Utf8\] to the signature OneOf(.*) failed(.|\n)* +statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to 'approx_percentile_cont_with_weight' function: coercion from \[Int16, Int8, Utf8\] to the signature OneOf(.*) failed(.|\n)* SELECT approx_percentile_cont_with_weight(c3, c2, c1) FROM aggregate_test_100 # csv_query_approx_percentile_cont_with_histogram_bins statement error DataFusion error: External error: This feature is not implemented: Tdigest max_size value for 'APPROX_PERCENTILE_CONT' must be UInt > 0 literal \(got data type Int64\)\. SELECT c1, approx_percentile_cont(c3, 0.95, -1000) AS c3_p95 FROM aggregate_test_100 GROUP BY 1 ORDER BY 1 -statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to approx_percentile_cont function: coercion from \[Int16, Float64, Utf8\] to the signature OneOf(.*) failed(.|\n)* +statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to 'approx_percentile_cont' function: coercion from \[Int16, Float64, Utf8\] to the signature OneOf(.*) failed(.|\n)* SELECT approx_percentile_cont(c3, 0.95, c1) FROM aggregate_test_100 -statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to approx_percentile_cont function: coercion from \[Int16, Float64, Float64\] to the signature OneOf(.*) failed(.|\n)* +statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to 'approx_percentile_cont' function: coercion from \[Int16, Float64, Float64\] to the signature OneOf(.*) failed(.|\n)* SELECT approx_percentile_cont(c3, 0.95, 111.1) FROM aggregate_test_100 -statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to approx_percentile_cont function: coercion from \[Float64, Float64, Float64\] to the signature OneOf(.*) failed(.|\n)* +statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to 'approx_percentile_cont' function: coercion from \[Float64, Float64, Float64\] to the signature OneOf(.*) failed(.|\n)* SELECT approx_percentile_cont(c12, 0.95, 111.1) FROM aggregate_test_100 statement error DataFusion error: This feature is not implemented: Percentile value for 'APPROX_PERCENTILE_CONT' must be a literal diff --git a/datafusion/sqllogictest/test_files/array.slt b/datafusion/sqllogictest/test_files/array.slt index d804bb424fb1..01aca94a5dd8 100644 --- a/datafusion/sqllogictest/test_files/array.slt +++ b/datafusion/sqllogictest/test_files/array.slt @@ -1191,7 +1191,7 @@ from arrays_values_without_nulls; ## array_element (aliases: array_extract, list_extract, list_element) # Testing with empty arguments should result in an error -query error DataFusion error: Error during planning: array_element does not support zero arguments +query error DataFusion error: Error during planning: 'array_element' does not support zero arguments select array_element(); # array_element error @@ -2074,7 +2074,7 @@ select array_slice(a, -1, 2, 1), array_slice(a, -1, 2), [6.0] [6.0] [] [] # Testing with empty arguments should result in an error -query error DataFusion error: Error during planning: array_slice does not support zero arguments +query error DataFusion error: Error during planning: 'array_slice' does not support zero arguments select array_slice(); query error Failed to coerce arguments diff --git a/datafusion/sqllogictest/test_files/errors.slt b/datafusion/sqllogictest/test_files/errors.slt index a153a2e9cecf..c54ba16e972a 100644 --- a/datafusion/sqllogictest/test_files/errors.slt +++ b/datafusion/sqllogictest/test_files/errors.slt @@ -108,11 +108,11 @@ query error select avg(c1, c12) from aggregate_test_100; # AggregateFunction with wrong argument type -statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to regr_slope function: coercion from +statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to 'regr_slope' function: coercion from select regr_slope(1, '2'); # WindowFunction using AggregateFunction wrong signature -statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to regr_slope function: coercion from +statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to 'regr_slope' function: coercion from select c9, regr_slope(c11, '2') over () as min1 @@ -120,7 +120,7 @@ from aggregate_test_100 order by c9 # WindowFunction wrong signature -statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to nth_value function: coercion from \[Int32, Int64, Int64\] to the signature OneOf\(\[Any\(0\), Any\(1\), Any\(2\)\]\) failed +statement error DataFusion error: Error during planning: Failed to coerce arguments to satisfy a call to 'nth_value' function: coercion from \[Int32, Int64, Int64\] to the signature OneOf\(\[Any\(0\), Any\(1\), Any\(2\)\]\) failed select c9, nth_value(c5, 2, 3) over (order by c9) as nv1 diff --git a/datafusion/sqllogictest/test_files/expr.slt b/datafusion/sqllogictest/test_files/expr.slt index b2aa4b3fac8f..b0c306635dd1 100644 --- a/datafusion/sqllogictest/test_files/expr.slt +++ b/datafusion/sqllogictest/test_files/expr.slt @@ -571,7 +571,7 @@ select repeat('-1.2', arrow_cast(3, 'Int32')); ---- -1.2-1.2-1.2 -query error DataFusion error: Error during planning: Internal error: Expect TypeSignatureClass::Native\(LogicalType\(Native\(Int64\), Int64\)\) but received Float64 +query error DataFusion error: Error during planning: Internal error: Function 'repeat' expects TypeSignatureClass::Native\(LogicalType\(Native\(Int64\), Int64\)\) but received Float64 select repeat('-1.2', 3.2); query T diff --git a/datafusion/sqllogictest/test_files/functions.slt b/datafusion/sqllogictest/test_files/functions.slt index 4213de0235e4..838387965e6a 100644 --- a/datafusion/sqllogictest/test_files/functions.slt +++ b/datafusion/sqllogictest/test_files/functions.slt @@ -842,7 +842,7 @@ SELECT greatest(-1, 1, 2.3, 123456789, 3 + 5, -(-4), abs(-9.0)) 123456789 -query error greatest does not support zero arguments +query error 'greatest' does not support zero argument SELECT greatest() query I @@ -1040,7 +1040,7 @@ SELECT least(-1, 1, 2.3, 123456789, 3 + 5, -(-4), abs(-9.0)) -1 -query error least does not support zero arguments +query error 'least' does not support zero arguments SELECT least() query I diff --git a/datafusion/sqllogictest/test_files/math.slt b/datafusion/sqllogictest/test_files/math.slt index 37b5a378fc02..a3cf1a4e573f 100644 --- a/datafusion/sqllogictest/test_files/math.slt +++ b/datafusion/sqllogictest/test_files/math.slt @@ -126,15 +126,15 @@ statement error SELECT abs(1, 2); # abs: unsupported argument type -query error DataFusion error: Error during planning: The signature expected NativeType::Numeric but received NativeType::String +query error DataFusion error: Error during planning: Function 'abs' expects NativeType::Numeric but received NativeType::String SELECT 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: The signature expected NativeType::Numeric but received NativeType::String +query error DataFusion error: Error during planning: Function 'abs' expects NativeType::Numeric but received NativeType::String select abs('-1.2'); -query error DataFusion error: Error during planning: The signature expected NativeType::Numeric but received NativeType::String +query error DataFusion error: Error during planning: Function 'abs' expects NativeType::Numeric but received NativeType::String select abs(arrow_cast('-1.2', 'Utf8')); statement ok diff --git a/datafusion/sqllogictest/test_files/scalar.slt b/datafusion/sqllogictest/test_files/scalar.slt index 0add75c7c152..cb363eee42ee 100644 --- a/datafusion/sqllogictest/test_files/scalar.slt +++ b/datafusion/sqllogictest/test_files/scalar.slt @@ -1945,7 +1945,7 @@ select position('' in '') ---- 1 -query error DataFusion error: Error during planning: The signature expected NativeType::String but received NativeType::Int64 +query error DataFusion error: Error during planning: Function 'strpos' expects NativeType::String but received NativeType::Int64 select position(1 in 1) query I