cubesql-engine (chore): remove duplicates (#8321)

* cubesql-engine (chore): remove duplicates
Removed 2nd identical coercion function and renamed the only one into more general

Author: KSDaemon

rust/cubesql/cubesql/src/compile/engine/df/coerce.rs

@@ -47,29 +47,7 @@ pub fn numerical_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<Da
     }
 }
 
-pub fn if_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<DataType> {
-    // same type => all good
-    if lhs_type == rhs_type {
-        return Some(lhs_type.clone());
-    }
-
-    let hack_ty = match (lhs_type, rhs_type) {
-        (_, DataType::Null) => Some(lhs_type.clone()),
-        (DataType::Null, _) => Some(rhs_type.clone()),
-        //
-        (DataType::Utf8, DataType::UInt64) => Some(DataType::Utf8),
-        (DataType::Utf8, DataType::Int64) => Some(DataType::Utf8),
-        //
-        (DataType::UInt64, DataType::Utf8) => Some(DataType::Utf8),
-        (DataType::Int64, DataType::Utf8) => Some(DataType::Utf8),
-        //
-        _ => None,
-    };
-
-    hack_ty.or_else(|| numerical_coercion(lhs_type, rhs_type))
-}
-
-pub fn least_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<DataType> {
+pub fn common_type_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<DataType> {
     // same type => all good
     if lhs_type == rhs_type {
         return Some(lhs_type.clone());

rust/cubesql/cubesql/src/compile/engine/udf/common.rs

@@ -40,10 +40,7 @@ use sha1_smol::Sha1;
 
 use crate::{
     compile::engine::{
-        df::{
-            coerce::{if_coercion, least_coercion},
-            columar::if_then_else,
-        },
+        df::{coerce::common_type_coercion, columar::if_then_else},
         udf::utils::*,
     },
     sql::SessionState,
@@ -425,13 +422,14 @@ pub fn create_if_udf() -> ScalarUDF {
         let left = &args[1];
         let right = &args[2];
 
-        let return_type = if_coercion(left.data_type(), right.data_type()).ok_or_else(|| {
-            DataFusionError::Execution(format!(
-                "Positive and negative results must be the same type, actual: [{}, {}]",
-                left.data_type(),
-                right.data_type(),
-            ))
-        })?;
+        let return_type =
+            common_type_coercion(left.data_type(), right.data_type()).ok_or_else(|| {
+                DataFusionError::Execution(format!(
+                    "Positive and negative results must be the same type, actual: [{}, {}]",
+                    left.data_type(),
+                    right.data_type(),
+                ))
+            })?;
 
         let cond_array = match condition.data_type() {
             // // Arrow doesnt support UTF8 -> Boolean cast
@@ -468,7 +466,7 @@ pub fn create_if_udf() -> ScalarUDF {
     let return_type: ReturnTypeFunction = Arc::new(move |types| {
         assert!(types.len() == 3);
 
-        let base_type = if_coercion(&types[1], &types[2]).ok_or_else(|| {
+        let base_type = common_type_coercion(&types[1], &types[2]).ok_or_else(|| {
             DataFusionError::Execution(format!(
                 "Positive and negative results must be the same type, actual: [{}, {}]",
                 &types[1], &types[2],
@@ -486,21 +484,23 @@ pub fn create_if_udf() -> ScalarUDF {
     )
 }
 
-// LEAST() function in MySQL is used to find smallest values from given arguments respectively. If any given value is NULL, it return NULLs. Otherwise it returns the smallest value.
+// LEAST() function in MySQL is used to find the smallest values from given arguments respectively.
+// If any given value is NULL, it returns NULLs. Otherwise, it returns the smallest value.
 pub fn create_least_udf() -> ScalarUDF {
     let fun = make_scalar_function(move |args: &[ArrayRef]| {
         assert!(args.len() == 2);
 
         let left = &args[0];
         let right = &args[1];
 
-        let base_type = least_coercion(&left.data_type(), &right.data_type()).ok_or_else(|| {
-            DataFusionError::Execution(format!(
-                "Unable to coercion types, actual: [{}, {}]",
-                &left.data_type(),
-                &right.data_type(),
-            ))
-        })?;
+        let base_type =
+            common_type_coercion(&left.data_type(), &right.data_type()).ok_or_else(|| {
+                DataFusionError::Execution(format!(
+                    "Unable to coercion types, actual: [{}, {}]",
+                    &left.data_type(),
+                    &right.data_type(),
+                ))
+            })?;
 
         let result = if left.is_null(0) {
             cast(&left, &base_type)?
@@ -548,7 +548,7 @@ pub fn create_least_udf() -> ScalarUDF {
             return Ok(Arc::new(DataType::Null));
         }
 
-        let base_type = least_coercion(&types[0], &types[1]).ok_or_else(|| {
+        let base_type = common_type_coercion(&types[0], &types[1]).ok_or_else(|| {
             DataFusionError::Execution(format!(
                 "Unable to coercion types, actual: [{}, {}]",
                 &types[0], &types[1],