replace all coerciblev1

Author: jayzhan211

datafusion/expr-common/Cargo.toml

@@ -40,4 +40,5 @@ path = "src/lib.rs"
 arrow = { workspace = true }
 datafusion-common = { workspace = true }
 itertools = { workspace = true }
+indexmap = { workspace = true }
 paste = "^1.0"

datafusion/expr-common/src/signature.rs

@@ -24,7 +24,8 @@ use std::num::NonZeroUsize;
 use crate::type_coercion::aggregates::NUMERICS;
 use arrow::datatypes::{DataType, IntervalUnit, TimeUnit};
 use datafusion_common::types::{LogicalType, LogicalTypeRef, NativeType};
-use datafusion_common::{HashSet, Result};
+use datafusion_common::Result;
+use indexmap::IndexSet;
 use itertools::Itertools;
 
 /// Constant that is used as a placeholder for any valid timezone.
@@ -230,19 +231,21 @@ impl Display for TypeSignatureClass {
 impl TypeSignatureClass {
     /// Return the default casted type for the given `TypeSignatureClass`
     /// We return the largest common type for the given `TypeSignatureClass`
-    pub fn default_casted_type(&self, data_type: &DataType) -> Result<DataType> {
+    pub fn default_casted_type(
+        &self,
+        logical_type: &NativeType,
+        data_type: &DataType,
+    ) -> Result<DataType> {
         Ok(match self {
+            // TODO: Able to elimnate this special case?
+            // Not consistent with Postgres and DuckDB but to avoid regression we implicit cast string to timestamp
+            TypeSignatureClass::Timestamp if logical_type == &NativeType::String => {
+                DataType::Timestamp(TimeUnit::Nanosecond, None)
+            }
             TypeSignatureClass::Native(logical_type) => {
                 return logical_type.native().default_cast_for(data_type)
             }
-            TypeSignatureClass::Timestamp => {
-                DataType::Timestamp(TimeUnit::Nanosecond, None)
-            }
-            TypeSignatureClass::Date => DataType::Date64,
-            TypeSignatureClass::Time => DataType::Time64(TimeUnit::Nanosecond),
-            TypeSignatureClass::Interval => DataType::Interval(IntervalUnit::DayTime),
-            TypeSignatureClass::Duration => DataType::Duration(TimeUnit::Nanosecond),
-            TypeSignatureClass::Integer => DataType::Int64,
+            _ => data_type.clone(),
         })
     }
 }
@@ -407,7 +410,7 @@ impl TypeSignature {
             TypeSignature::CoercibleV2(coercions) => coercions
                 .iter()
                 .map(|c| {
-                    let mut all_types: HashSet<DataType> =
+                    let mut all_types: IndexSet<DataType> =
                         get_possible_types_from_signature_classes(&c.desired_type)
                             .into_iter()
                             .collect();

datafusion/expr/src/type_coercion/functions.rs

@@ -203,6 +203,7 @@ fn is_well_supported_signature(type_signature: &TypeSignature) -> bool {
             | TypeSignature::Numeric(_)
             | TypeSignature::String(_)
             | TypeSignature::Coercible(_)
+            | TypeSignature::CoercibleV2(_)
             | TypeSignature::Any(_)
             | TypeSignature::Nullary
             | TypeSignature::Comparable(_)
@@ -617,8 +618,9 @@ fn get_valid_types(
                         .iter()
                         .any(|t| is_matched_type(t, &current_logical_type))
                 {
-                    let casted_type =
-                        param.desired_type.default_casted_type(current_type)?;
+                    let casted_type = param
+                        .desired_type
+                        .default_casted_type(&current_logical_type, current_type)?;
                     new_types.push(casted_type);
                 } else {
                     return internal_err!(

datafusion/functions/src/datetime/date_part.rs

@@ -45,7 +45,7 @@ use datafusion_expr::{
     ColumnarValue, Documentation, ReturnInfo, ReturnTypeArgs, ScalarUDFImpl, Signature,
     TypeSignature, Volatility,
 };
-use datafusion_expr_common::signature::TypeSignatureClass;
+use datafusion_expr_common::signature::{Coercion, TypeSignatureClass};
 use datafusion_macros::user_doc;
 
 #[user_doc(
@@ -95,25 +95,55 @@ impl DatePartFunc {
         Self {
             signature: Signature::one_of(
                 vec![
-                    TypeSignature::Coercible(vec![
-                        TypeSignatureClass::Native(logical_string()),
-                        TypeSignatureClass::Timestamp,
+                    TypeSignature::CoercibleV2(vec![
+                        Coercion {
+                            desired_type: TypeSignatureClass::Native(logical_string()),
+                            allowed_casts: vec![],
+                        },
+                        Coercion {
+                            desired_type: TypeSignatureClass::Timestamp,
+                            allowed_casts: vec![],
+                        },
                     ]),
-                    TypeSignature::Coercible(vec![
-                        TypeSignatureClass::Native(logical_string()),
-                        TypeSignatureClass::Date,
+                    TypeSignature::CoercibleV2(vec![
+                        Coercion {
+                            desired_type: TypeSignatureClass::Native(logical_string()),
+                            allowed_casts: vec![],
+                        },
+                        Coercion {
+                            desired_type: TypeSignatureClass::Date,
+                            allowed_casts: vec![],
+                        },
                     ]),
-                    TypeSignature::Coercible(vec![
-                        TypeSignatureClass::Native(logical_string()),
-                        TypeSignatureClass::Time,
+                    TypeSignature::CoercibleV2(vec![
+                        Coercion {
+                            desired_type: TypeSignatureClass::Native(logical_string()),
+                            allowed_casts: vec![],
+                        },
+                        Coercion {
+                            desired_type: TypeSignatureClass::Time,
+                            allowed_casts: vec![],
+                        },
                     ]),
-                    TypeSignature::Coercible(vec![
-                        TypeSignatureClass::Native(logical_string()),
-                        TypeSignatureClass::Interval,
+                    TypeSignature::CoercibleV2(vec![
+                        Coercion {
+                            desired_type: TypeSignatureClass::Native(logical_string()),
+                            allowed_casts: vec![],
+                        },
+                        Coercion {
+                            desired_type: TypeSignatureClass::Interval,
+                            allowed_casts: vec![],
+                        },
                     ]),
-                    TypeSignature::Coercible(vec![
-                        TypeSignatureClass::Native(logical_string()),
-                        TypeSignatureClass::Duration,
+                    TypeSignature::CoercibleV2(vec![
+                        Coercion {
+                            desired_type: TypeSignatureClass::Native(logical_string()),
+                            allowed_casts: vec![],
+                        },
+                        Coercion {
+                            desired_type: TypeSignatureClass::Duration,
+                            allowed_casts: vec![],
+                        },
                     ]),
                 ],
                 Volatility::Immutable,