feat: add implicit native coercion constructor

datafusion/expr-common/src/signature.rs

@@ -1025,17 +1025,16 @@ fn get_data_types(native_type: &NativeType) -> Vec<DataType> {
 /// # Examples
 ///
 /// ```
-/// use datafusion_common::types::{logical_binary, logical_string, NativeType};
+/// use datafusion_common::types::{logical_binary, logical_string};
 /// use datafusion_expr_common::signature::{Coercion, TypeSignatureClass};
 ///
 /// // 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()),
+/// let implicit = Coercion::new_implicit_native(
+///     logical_string(),
 ///     vec![TypeSignatureClass::Native(logical_binary())],
-///     NativeType::String,
 /// );
 /// ```
 ///
@@ -1118,6 +1117,22 @@ impl Coercion {
         }
     }
 
+    /// Create a new coercion to a native logical type with implicit coercion rules.
+    ///
+    /// The native type of `desired_type` is used as the default type when coercing
+    /// from `allowed_source_types`.
+    pub fn new_implicit_native(
+        desired_type: LogicalTypeRef,
+        allowed_source_types: Vec<TypeSignatureClass>,
+    ) -> Self {
+        let default_casted_type = desired_type.native().clone();
+        Self::new_implicit(
+            TypeSignatureClass::Native(desired_type),
+            allowed_source_types,
+            default_casted_type,
+        )
+    }
+
     pub fn with_encoding_preservation(
         mut self,
         encoding_preservation: EncodingPreservation,
@@ -2245,6 +2260,23 @@ mod tests {
         assert_snapshot!(implicit_with_multiple_sources, @"Int64");
     }
 
+    #[test]
+    fn test_new_implicit_native() {
+        let allowed_source_types = vec![TypeSignatureClass::Numeric];
+
+        assert_eq!(
+            Coercion::new_implicit_native(
+                logical_float64(),
+                allowed_source_types.clone(),
+            ),
+            Coercion::new_implicit(
+                TypeSignatureClass::Native(logical_float64()),
+                allowed_source_types,
+                NativeType::Float64,
+            )
+        );
+    }
+
     #[test]
     fn test_coercion_encoding_preservation_affects_equality() {
         assert!(!EncodingPreservation::default().preserve_dictionary());

datafusion/functions-aggregate/src/approx_percentile_cont.rs

@@ -139,10 +139,9 @@ impl ApproxPercentileCont {
                         vec![TypeSignatureClass::Numeric],
                         NativeType::Float64,
                     ),
-                    Coercion::new_implicit(
-                        TypeSignatureClass::Native(logical_float64()),
+                    Coercion::new_implicit_native(
+                        logical_float64(),
                         vec![TypeSignatureClass::Numeric],
-                        NativeType::Float64,
                     ),
                 ]),
                 // 3 args - numeric, percentile (float), number of centroid for T-Digest (integer)
@@ -152,10 +151,9 @@ impl ApproxPercentileCont {
                         vec![TypeSignatureClass::Numeric],
                         NativeType::Float64,
                     ),
-                    Coercion::new_implicit(
-                        TypeSignatureClass::Native(logical_float64()),
+                    Coercion::new_implicit_native(
+                        logical_float64(),
                         vec![TypeSignatureClass::Numeric],
-                        NativeType::Float64,
                     ),
                     Coercion::new_implicit(
                         TypeSignatureClass::Integer,

datafusion/functions/src/unicode/reverse.rs

@@ -25,7 +25,7 @@ use DataType::{LargeUtf8, Utf8, Utf8View};
 use arrow::array::{Array, ArrayRef, AsArray, StringArrayType};
 use arrow::datatypes::DataType;
 use datafusion_common::Result;
-use datafusion_common::types::{NativeType, logical_string};
+use datafusion_common::types::logical_string;
 use datafusion_expr::{
     Coercion, ColumnarValue, Documentation, EncodingPreservation, ScalarFunctionArgs,
     ScalarUDFImpl, Signature, TypeSignatureClass, Volatility,
@@ -62,10 +62,9 @@ impl ReverseFunc {
         Self {
             signature: Signature::coercible(
                 vec![
-                    Coercion::new_implicit(
-                        TypeSignatureClass::Native(logical_string()),
+                    Coercion::new_implicit_native(
+                        logical_string(),
                         vec![TypeSignatureClass::Any],
-                        NativeType::String,
                     )
                     .with_encoding_preservation(EncodingPreservation::dictionary()),
                 ],