feat: fmt

Author: wszhdshys

src/binder/expr.rs

@@ -142,14 +142,15 @@ impl<'a, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, '_, T
                     trim_where: *trim_where,
                 })
             }
-            Expr::Exists {subquery, negated} => {
+            Expr::Exists { subquery, negated } => {
                 let (sub_query, column) = self.bind_subquery(subquery)?;
                 let (_, sub_query) = if !self.context.is_step(&QueryBindStep::Where) {
                     self.bind_temp_table(column, sub_query)?
                 } else {
                     (ScalarExpression::ColumnRef(column), sub_query)
                 };
-                self.context.sub_query(SubQueryType::ExistsSubQuery(*negated, sub_query));
+                self.context
+                    .sub_query(SubQueryType::ExistsSubQuery(*negated, sub_query));
                 Ok(ScalarExpression::Constant(DataValue::Boolean(true)))
             }
             Expr::Subquery(subquery) => {

src/binder/select.rs

@@ -21,7 +21,9 @@ use super::{
 use crate::catalog::{ColumnCatalog, ColumnRef, ColumnSummary, TableName};
 use crate::errors::DatabaseError;
 use crate::execution::dql::join::joins_nullable;
+use crate::expression::agg::AggKind;
 use crate::expression::{AliasType, BinaryOperator};
+use crate::planner::operator::aggregate::AggregateOperator;
 use crate::planner::operator::function_scan::FunctionScanOperator;
 use crate::planner::operator::insert::InsertOperator;
 use crate::planner::operator::join::JoinCondition;
@@ -30,13 +32,15 @@ use crate::planner::operator::union::UnionOperator;
 use crate::planner::{Childrens, LogicalPlan, SchemaOutput};
 use crate::storage::Transaction;
 use crate::types::tuple::{Schema, SchemaRef};
+use crate::types::value::Utf8Type;
+use crate::types::LogicalType::Char;
 use crate::types::{ColumnId, LogicalType};
 use itertools::Itertools;
-use sqlparser::ast::{CharLengthUnits, Distinct, Expr, Ident, Join, JoinConstraint, JoinOperator, Offset, OrderByExpr, Query, Select, SelectInto, SelectItem, SetExpr, SetOperator, SetQuantifier, TableAlias, TableFactor, TableWithJoins};
-use crate::expression::agg::AggKind;
-use crate::planner::operator::aggregate::AggregateOperator;
-use crate::types::LogicalType::Char;
-use crate::types::value::Utf8Type;
+use sqlparser::ast::{
+    CharLengthUnits, Distinct, Expr, Ident, Join, JoinConstraint, JoinOperator, Offset,
+    OrderByExpr, Query, Select, SelectInto, SelectItem, SetExpr, SetOperator, SetQuantifier,
+    TableAlias, TableFactor, TableWithJoins,
+};
 
 impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'a, 'b, T, A> {
     pub(crate) fn bind_query(&mut self, query: &Query) -> Result<LogicalPlan, DatabaseError> {
@@ -267,9 +271,9 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                 let mut tables = plan.referenced_table();
 
                 if let Some(TableAlias {
-                                name,
-                                columns: alias_column,
-                            }) = alias
+                    name,
+                    columns: alias_column,
+                }) = alias
                 {
                     if tables.len() > 1 {
                         return Err(DatabaseError::UnsupportedStmt(
@@ -291,9 +295,9 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                     let mut plan = FunctionScanOperator::build(function);
 
                     if let Some(TableAlias {
-                                    name,
-                                    columns: alias_column,
-                                }) = alias
+                        name,
+                        columns: alias_column,
+                    }) = alias
                     {
                         table_alias = Some(Arc::new(name.value.to_lowercase()));
 
@@ -600,17 +604,13 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                 let (mut plan, join_ty) = match sub_query {
                     SubQueryType::SubQuery(plan) => (plan, JoinType::Inner),
                     SubQueryType::ExistsSubQuery(is_not, plan) => {
-                        let limit = LimitOperator::build(
-                            None,
-                            Some(1),
-                            plan,
-                        );
+                        let limit = LimitOperator::build(None, Some(1), plan);
                         let mut agg = AggregateOperator::build(
                             limit,
                             vec![ScalarExpression::AggCall {
                                 distinct: false,
                                 kind: AggKind::Count,
-                                args: vec![ScalarExpression::Constant(DataValue::Utf8{
+                                args: vec![ScalarExpression::Constant(DataValue::Utf8 {
                                     value: "*".to_string(),
                                     ty: Utf8Type::Fixed(1),
                                     unit: CharLengthUnits::Characters,
@@ -620,19 +620,32 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                             vec![],
                             false,
                         );
-                        let filter = FilterOperator::build(ScalarExpression::Binary {
-                            op: if is_not { BinaryOperator::NotEq } else { BinaryOperator::Eq },
-                            left_expr: Box::new(ScalarExpression::ColumnRef(agg.output_schema()[0].clone())),
-                            right_expr: Box::new(ScalarExpression::Constant(DataValue::Int32(1))),
-                            evaluator: None,
-                            ty: LogicalType::Boolean,
-                        },
-                        agg,
-                        false);
+                        let filter = FilterOperator::build(
+                            ScalarExpression::Binary {
+                                op: if is_not {
+                                    BinaryOperator::NotEq
+                                } else {
+                                    BinaryOperator::Eq
+                                },
+                                left_expr: Box::new(ScalarExpression::ColumnRef(
+                                    agg.output_schema()[0].clone(),
+                                )),
+                                right_expr: Box::new(ScalarExpression::Constant(DataValue::Int32(
+                                    1,
+                                ))),
+                                evaluator: None,
+                                ty: LogicalType::Boolean,
+                            },
+                            agg,
+                            false,
+                        );
                         let projection = ProjectOperator {
-                            exprs: vec![ScalarExpression::Constant(DataValue::Int32(1))]
+                            exprs: vec![ScalarExpression::Constant(DataValue::Int32(1))],
                         };
-                        let plan = LogicalPlan::new(Operator::Project(projection), Childrens::Only(filter));
+                        let plan = LogicalPlan::new(
+                            Operator::Project(projection),
+                            Childrens::Only(filter),
+                        );
                         children = LJoinOperator::build(
                             children,
                             plan,