Fix Type Coercion for UDF Arguments

datafusion/common/Cargo.toml

@@ -64,7 +64,7 @@ log = { workspace = true }
 object_store = { workspace = true, optional = true }
 parquet = { workspace = true, optional = true, default-features = true }
 paste = "1.0.15"
-pyo3 = { version = "0.23.3", optional = true }
+pyo3 = { version = "0.23.4", optional = true }
 recursive = { workspace = true, optional = true }
 sqlparser = { workspace = true }
 tokio = { workspace = true }

datafusion/common/src/types/native.rs

@@ -436,6 +436,12 @@ impl NativeType {
         )
     }
 
+    #[inline]
+    pub fn is_binary(&self) -> bool {
+        use NativeType::*;
+        matches!(self, Binary | FixedSizeBinary(_))
+    }
+
     #[inline]
     pub fn is_timestamp(&self) -> bool {
         matches!(self, NativeType::Timestamp(_, _))

datafusion/common/src/utils/mod.rs

@@ -588,6 +588,7 @@ pub fn base_type(data_type: &DataType) -> DataType {
         DataType::List(field)
         | DataType::LargeList(field)
         | DataType::FixedSizeList(field, _) => base_type(field.data_type()),
+        DataType::Dictionary(_, value_type) => base_type(value_type),
         _ => data_type.to_owned(),
     }
 }

datafusion/expr-common/src/signature.rs

@@ -126,9 +126,17 @@ pub enum TypeSignature {
     Exact(Vec<DataType>),
     /// One or more arguments belonging to the [`TypeSignatureClass`], in order.
     ///
-    /// For example, `Coercible(vec![logical_float64()])` accepts
-    /// arguments like `vec![Int32]` or `vec![Float32]`
-    /// since i32 and f32 can be cast to f64
+    /// `Coercible(vec![TypeSignatureClass::Native(...)])` is designed to cast between the same
+    /// logical type.
+    ///
+    /// For example, `Coercible(vec![TypeSignatureClass::Native(logical_int64())])` accepts
+    /// arguments like `vec![Int32]` since i32 is the same logical type as i64.
+    ///
+    /// Coercible(vec![TypeSignatureClass::Integer(...)])` accepts any
+    /// integer type (`NativeType::is_integer`) castable to the target integer `NativeType`.
+    ///
+    /// For example, `Coercible(vec![TypeSignatureClass::Integer(logical_int64())])` accepts
+    /// arguments like `vec![Int32]` since i32 can be cast to i64.
     ///
     /// For functions that take no arguments (e.g. `random()`) see [`TypeSignature::Nullary`].
     Coercible(Vec<TypeSignatureClass>),
@@ -213,9 +221,8 @@ pub enum TypeSignatureClass {
     Interval,
     Duration,
     Native(LogicalTypeRef),
-    // TODO:
-    // Numeric
-    // Integer
+    Numeric(LogicalTypeRef),
+    Integer(LogicalTypeRef),
 }
 
 impl Display for TypeSignatureClass {
@@ -376,7 +383,9 @@ impl TypeSignature {
             TypeSignature::Coercible(types) => types
                 .iter()
                 .map(|logical_type| match logical_type {
-                    TypeSignatureClass::Native(l) => get_data_types(l.native()),
+                    TypeSignatureClass::Native(l)
+                    | TypeSignatureClass::Numeric(l)
+                    | TypeSignatureClass::Integer(l) => get_data_types(l.native()),
                     TypeSignatureClass::Timestamp => {
                         vec![
                             DataType::Timestamp(TimeUnit::Nanosecond, None),
@@ -498,7 +507,7 @@ impl Signature {
         }
     }
 
-    /// A specified number of numeric arguments
+    /// A specified number of string arguments
     pub fn string(arg_count: usize, volatility: Volatility) -> Self {
         Self {
             type_signature: TypeSignature::String(arg_count),