findepi commented on code in PR #14440:
URL: https://github.com/apache/datafusion/pull/14440#discussion_r1961727057
##########
datafusion/expr-common/src/signature.rs:
##########
@@ -466,6 +551,186 @@ fn get_data_types(native_type: &NativeType) ->
Vec<DataType> {
}
}
+/// Represents type coercion rules for function arguments, specifying both the
desired type
+/// and optional implicit coercion rules for source types.
+///
+/// # Examples
+///
+/// ```
+/// use datafusion_expr_common::signature::{Coercion, TypeSignatureClass};
+/// use datafusion_common::types::{NativeType, logical_binary, logical_string};
+///
+/// // Exact coercion that only accepts timestamp types
+/// let exact = Coercion::new_exact(TypeSignatureClass::Timestamp);
+///
+/// // Implicit coercion that accepts string types but can coerce from binary
types
+/// let implicit = Coercion::new_implicit(
+/// TypeSignatureClass::Native(logical_string()),
+/// vec![TypeSignatureClass::Native(logical_binary())],
+/// NativeType::String
+/// );
+/// ```
+///
+/// There are two variants:
+///
+/// * `Exact` - Only accepts arguments that exactly match the desired type
+/// * `Implicit` - Accepts the desired type and can coerce from specified
source types
+#[derive(Debug, Clone, Eq, PartialOrd)]
+pub enum Coercion {
+ /// Coercion that only accepts arguments exactly matching the desired type.
+ Exact {
+ /// The required type for the argument
+ desired_type: TypeSignatureClass,
+ },
+
+ /// Coercion that accepts the desired type and can implicitly coerce from
other types.
+ Implicit {
+ /// The primary desired type for the argument
+ desired_type: TypeSignatureClass,
+ /// Rules for implicit coercion from other types
+ implicit_coercion: ImplicitCoercion,
+ },
Review Comment:
I don't know what `AnyType` is. I wrote `any type X' coercible to X`.
> Datafusion doesn't need this
If "this" refers to "AnyType", then I don't have opinion at least until I
know what it means.
if "this" refers `ability for a function f(s) to express the most basic need:
"f takes s being a type X, so the call succeeds for any type X' coercible to
X"`, then i do think DF needs this.
Let's consider example of `substr(s, i)` function.
The call to substr should succeed for `i` being any integer type coercible
to UInt64 or Int64.
The function itself doesn't need to know what "coercible" or "parameter
coercible" means.
Yes, it's physically possible design to require that functions know what
"coercible" or "parameter coercible" mean, for every function separately. It's
doable, just it doesn't make a of sense. For example, integer types should be
coercible to broader integer types the same way regardless whether it's in
context of UNION ALL, EXCEPT, a function call, or an operator.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscr...@datafusion.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: github-unsubscr...@datafusion.apache.org
For additional commands, e-mail: github-h...@datafusion.apache.org
