revert native to original and add anynative

Author: shehabgamin

datafusion/expr-common/src/signature.rs

@@ -126,13 +126,19 @@ pub enum TypeSignature {
     Exact(Vec<DataType>),
     /// One or more arguments belonging to the [`TypeSignatureClass`], in order.
     ///
-    /// `Coercible(vec![TypeSignatureClass::Native(...)])` accepts any type castable to the
+    /// `Coercible(vec![TypeSignatureClass::AnyNative(...)])` accepts any type castable to the
     /// target `NativeType` through the explicit set of type conversion rules defined in
-    /// `NativeType::default_cast_for`
+    /// `NativeType::default_cast_for`.
     ///
-    /// For example, `Coercible(vec![TypeSignatureClass::Native(logical_float64())])` accepts
+    /// For example, `Coercible(vec![TypeSignatureClass::AnyNative(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`.
     ///
@@ -222,9 +228,9 @@ pub enum TypeSignatureClass {
     Interval,
     Duration,
     Native(LogicalTypeRef),
+    AnyNative(LogicalTypeRef),
+    Numeric(LogicalTypeRef),
     Integer(LogicalTypeRef),
-    // TODO:
-    // Numeric
 }
 
 impl Display for TypeSignatureClass {
@@ -385,9 +391,10 @@ impl TypeSignature {
             TypeSignature::Coercible(types) => types
                 .iter()
                 .map(|logical_type| match logical_type {
-                    TypeSignatureClass::Native(l) | TypeSignatureClass::Integer(l) => {
-                        get_data_types(l.native())
-                    }
+                    TypeSignatureClass::Native(l)
+                    | TypeSignatureClass::AnyNative(l)
+                    | TypeSignatureClass::Numeric(l)
+                    | TypeSignatureClass::Integer(l) => get_data_types(l.native()),
                     TypeSignatureClass::Timestamp => {
                         vec![
                             DataType::Timestamp(TimeUnit::Nanosecond, None),

datafusion/expr/src/type_coercion/functions.rs

@@ -540,9 +540,32 @@ fn get_valid_types(
 
                 match target_type_class {
                     TypeSignatureClass::Native(native_type) => {
+                        let target_type = native_type.native();
+                        if &logical_type == target_type
+                            || logical_type == NativeType::Null
+                            || (target_type.is_numeric() && logical_type.is_numeric())
+                        {
+                            target_type.default_cast_for(current_type)
+                        } else {
+                            internal_err!(
+                                "Expect {target_type_class} but received {current_type}"
+                            )
+                        }
+                    }
+                    TypeSignatureClass::AnyNative(native_type) => {
                         let target_type = native_type.native();
                         target_type.default_cast_for(current_type)
                     }
+                    TypeSignatureClass::Numeric(native_type) => {
+                        let target_type = native_type.native();
+                        if target_type.is_numeric() && logical_type.is_numeric() {
+                            target_type.default_cast_for(current_type)
+                        } else {
+                            internal_err!(
+                                "Expect {target_type_class} but received {current_type}"
+                            )
+                        }
+                    }
                     TypeSignatureClass::Integer(native_type) => {
                         let target_type = native_type.native();
                         if target_type.is_integer() && logical_type.is_integer() {
@@ -591,7 +614,7 @@ fn get_valid_types(
             // Following the behavior of `TypeSignature::String`, we find the common string type.
             let string_indices: Vec<_> = target_types.iter().enumerate()
                 .filter(|(_, t)| {
-                    matches!(t, TypeSignatureClass::Native(n) if n.native() == &NativeType::String)
+                    matches!(t, TypeSignatureClass::Native(n) | TypeSignatureClass::AnyNative(n) if n.native() == &NativeType::String)
                 })
                 .map(|(i, _)| i)
                 .collect();