feat: Implicit transformation in set operation (#284)

* Some implicit conversions in the set operation have been implemented, but the specifics still need to be added

* The max_type function that comes with Logicaltype is used to optimize the judgment logic

* fmt

Author: wszhdshys

src/binder/select.rs

@@ -36,6 +36,7 @@ use crate::types::tuple::{Schema, SchemaRef};
 use crate::types::value::Utf8Type;
 use crate::types::{ColumnId, LogicalType};
 use itertools::Itertools;
+use sqlparser::ast::CharLengthUnits::Characters;
 use sqlparser::ast::{
     CharLengthUnits, Distinct, Expr, Ident, Join, JoinConstraint, JoinOperator, Offset,
     OrderByExpr, Query, Select, SelectInto, SelectItem, SetExpr, SetOperator, SetQuantifier,
@@ -156,6 +157,55 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
         Ok(plan)
     }
 
+    fn bind_set_cast(
+        &self,
+        mut left_plan: LogicalPlan,
+        mut right_plan: LogicalPlan,
+    ) -> Result<(LogicalPlan, LogicalPlan), DatabaseError> {
+        let mut left_cast = vec![];
+        let mut right_cast = vec![];
+
+        let left_schema = left_plan.output_schema();
+        let right_schema = right_plan.output_schema();
+
+        for (left_schema, right_schema) in left_schema.iter().zip(right_schema.iter()) {
+            let cast_type =
+                LogicalType::max_logical_type(left_schema.datatype(), right_schema.datatype())?;
+            if &cast_type != left_schema.datatype() {
+                left_cast.push(ScalarExpression::TypeCast {
+                    expr: Box::new(ScalarExpression::ColumnRef(left_schema.clone())),
+                    ty: cast_type.clone(),
+                });
+            } else {
+                left_cast.push(ScalarExpression::ColumnRef(left_schema.clone()));
+            }
+            if &cast_type != right_schema.datatype() {
+                right_cast.push(ScalarExpression::TypeCast {
+                    expr: Box::new(ScalarExpression::ColumnRef(right_schema.clone())),
+                    ty: cast_type.clone(),
+                });
+            } else {
+                right_cast.push(ScalarExpression::ColumnRef(right_schema.clone()));
+            }
+        }
+
+        if left_cast.len() > 0 {
+            left_plan = LogicalPlan::new(
+                Operator::Project(ProjectOperator { exprs: left_cast }),
+                Childrens::Only(left_plan),
+            );
+        }
+
+        if right_cast.len() > 0 {
+            right_plan = LogicalPlan::new(
+                Operator::Project(ProjectOperator { exprs: right_cast }),
+                Childrens::Only(right_plan),
+            );
+        }
+
+        Ok((left_plan, right_plan))
+    }
+
     pub(crate) fn bind_set_operation(
         &mut self,
         op: &SetOperator,
@@ -169,30 +219,29 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
         };
         let mut left_plan = self.bind_set_expr(left)?;
         let mut right_plan = self.bind_set_expr(right)?;
-        let fn_eq = |left_schema: &Schema, right_schema: &Schema| {
-            let left_len = left_schema.len();
 
-            if left_len != right_schema.len() {
-                return false;
-            }
-            for i in 0..left_len {
-                if left_schema[i].datatype() != right_schema[i].datatype() {
-                    return false;
-                }
-            }
-            true
-        };
+        let mut left_schema = left_plan.output_schema();
+        let mut right_schema = right_plan.output_schema();
 
-        let left_schema = left_plan.output_schema();
-        let right_schema = right_plan.output_schema();
+        let left_len = left_schema.len();
 
-        if !fn_eq(left_schema, right_schema) {
+        if left_len != right_schema.len() {
             return Err(DatabaseError::MisMatch(
-                "the output types on the left",
-                "the output types on the right",
+                "the lens on the left",
+                "the lens on the right",
             ));
         }
 
+        if !left_schema
+            .iter()
+            .zip(right_schema.iter())
+            .all(|(left, right)| left.datatype() == right.datatype())
+        {
+            (left_plan, right_plan) = self.bind_set_cast(left_plan, right_plan)?;
+            left_schema = left_plan.output_schema();
+            right_schema = right_plan.output_schema();
+        }
+
         match op {
             SetOperator::Union => {
                 if is_all {

tests/slt/sql_2016/E071_05.slt

@@ -1,43 +1,29 @@
 # E071-05: Columns combined via table operators need not have exactly the same data type
 
-# TODO: Columns combined via table operators need not have exactly the same data type
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_01_011 ( ID INT PRIMARY KEY, A INT );
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_01_012 ( ID INT PRIMARY KEY, B FLOAT );
-
-# SELECT A FROM TABLE_E071_05_01_011 UNION ALL SELECT B FROM TABLE_E071_05_01_012
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_01_021 ( ID INT PRIMARY KEY, A INT );
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_01_022 ( ID INT PRIMARY KEY, B FLOAT );
-
-# SELECT A FROM TABLE_E071_05_01_021 UNION DISTINCT SELECT B FROM TABLE_E071_05_01_022
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_01_031 ( ID INT PRIMARY KEY, A INT );
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_01_032 ( ID INT PRIMARY KEY, B FLOAT );
-
-# SELECT A FROM TABLE_E071_05_01_031 UNION SELECT B FROM TABLE_E071_05_01_032
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_02_011 ( ID INT PRIMARY KEY, A INT );
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_02_012 ( ID INT PRIMARY KEY, B FLOAT );
-
-# SELECT A FROM TABLE_E071_05_02_011 EXCEPT DISTINCT SELECT B FROM TABLE_E071_05_02_012
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_02_021 ( ID INT PRIMARY KEY, A INT );
-
-# statement ok
-# CREATE TABLE TABLE_E071_05_02_022 ( ID INT PRIMARY KEY, B FLOAT );
-
-# SELECT A FROM TABLE_E071_05_02_021 EXCEPT SELECT B FROM TABLE_E071_05_02_022
+statement ok
+CREATE TABLE TABLE_E071_05_01_011 ( ID INT PRIMARY KEY, A INT, C FLOAT );
+
+statement ok
+CREATE TABLE TABLE_E071_05_01_012 ( ID INT PRIMARY KEY, B FLOAT, D INT );
+
+statement ok
+INSERT INTO TABLE_E071_05_01_011(ID,A,C) VALUES (0,1,1.2),(1,2,2.3),(2,1,5.4)
+
+statement ok
+INSERT INTO TABLE_E071_05_01_012(ID,B,D) VALUES (1,2.12,23)
+
+query II rowsort
+SELECT A,C FROM TABLE_E071_05_01_011 UNION ALL SELECT B,D FROM TABLE_E071_05_01_012
+----
+1.0 1.2
+1.0 5.4
+2.0 2.3
+2.12 23.0
+
+query II rowsort
+SELECT B,D FROM TABLE_E071_05_01_012 UNION ALL SELECT A,C FROM TABLE_E071_05_01_011
+----
+1.0 1.2
+1.0 5.4
+2.0 2.3
+2.12 23.0