fmt

Author: wszhdshys

src/binder/select.rs

@@ -182,104 +182,83 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
             }
             true
         };
-        match (op, is_all) {
-            (SetOperator::Union, true) => {
-                let left_schema = left_plan.output_schema();
-                let right_schema = right_plan.output_schema();
-
-                if !fn_eq(left_schema, right_schema) {
-                    return Err(DatabaseError::MisMatch(
-                        "the output types on the left",
-                        "the output types on the right",
-                    ));
-                }
-                Ok(UnionOperator::build(
-                    left_schema.clone(),
-                    right_schema.clone(),
-                    left_plan,
-                    right_plan,
-                ))
-            }
-            (SetOperator::Union, false) => {
-                let left_schema = left_plan.output_schema();
-                let right_schema = right_plan.output_schema();
-
-                if !fn_eq(left_schema, right_schema) {
-                    return Err(DatabaseError::MisMatch(
-                        "the output types on the left",
-                        "the output types on the right",
-                    ));
-                }
-                let union_op = Operator::Union(UnionOperator {
-                    left_schema_ref: left_schema.clone(),
-                    _right_schema_ref: right_schema.clone(),
-                });
-                let distinct_exprs = left_schema
-                    .iter()
-                    .cloned()
-                    .map(ScalarExpression::ColumnRef)
-                    .collect_vec();
-
-                Ok(self.bind_distinct(
-                    LogicalPlan::new(
-                        union_op,
-                        Childrens::Twins {
-                            left: left_plan,
-                            right: right_plan,
-                        },
-                    ),
-                    distinct_exprs,
-                ))
-            }
-            (SetOperator::Except, true) => {
-                let left_schema = left_plan.output_schema();
-                let right_schema = right_plan.output_schema();
-
-                if !fn_eq(left_schema, right_schema) {
-                    return Err(DatabaseError::MisMatch(
-                        "the output types on the left",
-                        "the output types on the right",
-                    ));
+
+        let left_schema = left_plan.output_schema();
+        let right_schema = right_plan.output_schema();
+
+        if !fn_eq(left_schema, right_schema) {
+            return Err(DatabaseError::MisMatch(
+                "the output types on the left",
+                "the output types on the right",
+            ));
+        }
+
+        match op {
+            SetOperator::Union => {
+                if is_all {
+                    Ok(UnionOperator::build(
+                        left_schema.clone(),
+                        right_schema.clone(),
+                        left_plan,
+                        right_plan,
+                    ))
+                } else {
+                    let distinct_exprs = left_schema
+                        .iter()
+                        .cloned()
+                        .map(ScalarExpression::ColumnRef)
+                        .collect_vec();
+
+                    let union_op = Operator::Union(UnionOperator {
+                        left_schema_ref: left_schema.clone(),
+                        _right_schema_ref: right_schema.clone(),
+                    });
+
+                    Ok(self.bind_distinct(
+                        LogicalPlan::new(
+                            union_op,
+                            Childrens::Twins {
+                                left: left_plan,
+                                right: right_plan,
+                            },
+                        ),
+                        distinct_exprs,
+                    ))
                 }
-                Ok(ExceptOperator::build(
-                    left_schema.clone(),
-                    right_schema.clone(),
-                    left_plan,
-                    right_plan,
-                ))
             }
-            (SetOperator::Except, false) => {
-                let left_schema = left_plan.output_schema();
-                let right_schema = right_plan.output_schema();
-
-                if !fn_eq(left_schema, right_schema) {
-                    return Err(DatabaseError::MisMatch(
-                        "the output types on the left",
-                        "the output types on the right",
-                    ));
+            SetOperator::Except => {
+                if is_all {
+                    Ok(ExceptOperator::build(
+                        left_schema.clone(),
+                        right_schema.clone(),
+                        left_plan,
+                        right_plan,
+                    ))
+                } else {
+                    let distinct_exprs = left_schema
+                        .iter()
+                        .cloned()
+                        .map(ScalarExpression::ColumnRef)
+                        .collect_vec();
+
+                    let except_op = Operator::Except(ExceptOperator {
+                        left_schema_ref: left_schema.clone(),
+                        _right_schema_ref: right_schema.clone(),
+                    });
+
+                    Ok(self.bind_distinct(
+                        LogicalPlan::new(
+                            except_op,
+                            Childrens::Twins {
+                                left: left_plan,
+                                right: right_plan,
+                            },
+                        ),
+                        distinct_exprs,
+                    ))
                 }
-                let except_op = Operator::Except(ExceptOperator {
-                    left_schema_ref: left_schema.clone(),
-                    _right_schema_ref: right_schema.clone(),
-                });
-                let distinct_exprs = left_schema
-                    .iter()
-                    .cloned()
-                    .map(ScalarExpression::ColumnRef)
-                    .collect_vec();
-
-                Ok(self.bind_distinct(
-                    LogicalPlan::new(
-                        except_op,
-                        Childrens::Twins {
-                            left: left_plan,
-                            right: right_plan,
-                        },
-                    ),
-                    distinct_exprs,
-                ))
             }
-            (set_operator, _) => Err(DatabaseError::UnsupportedStmt(format!(
+            set_operator => Err(DatabaseError::UnsupportedStmt(format!(
                 "set operator: {:?}",
                 set_operator
             ))),