clean and fmt

Signed-off-by: AveryQi115 <[email protected]>

Author: AveryQi115

datafusion-optd-cli/src/main.rs

@@ -158,11 +158,10 @@ pub async fn main() -> Result<()> {
     };
 
     let mut session_config = SessionConfig::from_env()?.with_information_schema(true);
-    
+
     if !args.enable_logical {
         session_config.options_mut().optimizer.max_passes = 0;
     }
-    
 
     if let Some(batch_size) = args.batch_size {
         session_config = session_config.with_batch_size(batch_size);

optd-datafusion-bridge/src/from_optd.rs

@@ -1,28 +1,34 @@
-use std::{collections::HashMap, fmt::Display, sync::Arc};
+use std::{collections::HashMap, sync::Arc};
 
 use anyhow::{bail, Context, Result};
 use async_recursion::async_recursion;
 use datafusion::{
-    arrow::datatypes::{Schema, SchemaRef}, catalog::schema, common::DFSchema, datasource::source_as_provider, logical_expr::Operator, physical_expr, physical_plan::{
+    arrow::datatypes::{Schema, SchemaRef},
+    datasource::source_as_provider,
+    logical_expr::Operator,
+    physical_expr,
+    physical_plan::{
         self,
         aggregates::AggregateMode,
         expressions::create_aggregate_expr,
         joins::{
-            utils::{ColumnIndex, JoinFilter}, CrossJoinExec, PartitionMode
+            utils::{ColumnIndex, JoinFilter},
+            CrossJoinExec, PartitionMode,
         },
         projection::ProjectionExec,
         AggregateExpr, ExecutionPlan, PhysicalExpr,
-    }, scalar::ScalarValue
+    },
+    scalar::ScalarValue,
 };
 use optd_datafusion_repr::{
     plan_nodes::{
         BinOpExpr, BinOpType, ColumnRefExpr, ConstantExpr, ConstantType, Expr, FuncExpr, FuncType,
         JoinType, LogOpExpr, LogOpType, OptRelNode, OptRelNodeRef, OptRelNodeTyp, PhysicalAgg,
-        PhysicalFilter, PhysicalHashJoin, PhysicalNestedLoopJoin, PhysicalProjection, PhysicalScan,
-        PhysicalSort, PhysicalEmptyRelation, PlanNode, SortOrderExpr, SortOrderType,
+        PhysicalEmptyRelation, PhysicalFilter, PhysicalHashJoin, PhysicalNestedLoopJoin,
+        PhysicalProjection, PhysicalScan, PhysicalSort, PlanNode, SortOrderExpr, SortOrderType,
     },
-    PhysicalCollector,
     properties::schema::Schema as OptdSchema,
+    PhysicalCollector,
 };
 
 use crate::{physical_collector::CollectorExec, OptdPlanContext};
@@ -313,7 +319,8 @@ impl OptdPlanContext<'_> {
         let physical_expr = self.from_optd_expr(node.cond(), &Arc::new(filter_schema.clone()))?;
 
         if let JoinType::Cross = node.join_type() {
-            return Ok(Arc::new(CrossJoinExec::new(left_exec, right_exec)) as Arc<dyn ExecutionPlan + 'static>);
+            return Ok(Arc::new(CrossJoinExec::new(left_exec, right_exec))
+                as Arc<dyn ExecutionPlan + 'static>);
         }
 
         let join_type = match node.join_type() {
@@ -442,7 +449,7 @@ impl OptdPlanContext<'_> {
             }
             OptRelNodeTyp::PhysicalEmptyRelation => {
                 let physical_node = PhysicalEmptyRelation::from_rel_node(rel_node).unwrap();
-                let datafusion_schema : Schema = schema.into();
+                let datafusion_schema: Schema = schema.into();
                 Ok(Arc::new(datafusion::physical_plan::empty::EmptyExec::new(
                     physical_node.produce_one_row(),
                     Arc::new(datafusion_schema),

optd-datafusion-bridge/src/into_optd.rs

@@ -7,9 +7,9 @@ use datafusion::{
 use optd_core::rel_node::RelNode;
 use optd_datafusion_repr::plan_nodes::{
     BinOpExpr, BinOpType, ColumnRefExpr, ConstantExpr, Expr, ExprList, FuncExpr, FuncType,
-    JoinType, LogOpExpr, LogOpType, LogicalAgg, LogicalFilter, LogicalJoin, LogicalProjection,
-    LogicalScan, LogicalSort, LogicalEmptyRelation, OptRelNode, OptRelNodeRef, OptRelNodeTyp, PlanNode, SortOrderExpr,
-    SortOrderType,
+    JoinType, LogOpExpr, LogOpType, LogicalAgg, LogicalEmptyRelation, LogicalFilter, LogicalJoin,
+    LogicalProjection, LogicalScan, LogicalSort, OptRelNode, OptRelNodeRef, OptRelNodeTyp,
+    PlanNode, SortOrderExpr, SortOrderType,
 };
 
 use crate::OptdPlanContext;
@@ -117,7 +117,7 @@ impl OptdPlanContext<'_> {
                     expr,
                 )
                 .into_expr())
-            } 
+            }
             _ => bail!("Unsupported expression: {:?}", expr),
         }
     }
@@ -237,10 +237,18 @@ impl OptdPlanContext<'_> {
     fn into_optd_cross_join(&mut self, node: &logical_plan::CrossJoin) -> Result<LogicalJoin> {
         let left = self.into_optd_plan_node(node.left.as_ref())?;
         let right = self.into_optd_plan_node(node.right.as_ref())?;
-        Ok(LogicalJoin::new(left, right, ConstantExpr::bool(true).into_expr(), JoinType::Cross))
+        Ok(LogicalJoin::new(
+            left,
+            right,
+            ConstantExpr::bool(true).into_expr(),
+            JoinType::Cross,
+        ))
     }
 
-    fn into_optd_empty_relation(&mut self, node: &logical_plan::EmptyRelation) -> Result<LogicalEmptyRelation> {
+    fn into_optd_empty_relation(
+        &mut self,
+        node: &logical_plan::EmptyRelation,
+    ) -> Result<LogicalEmptyRelation> {
         Ok(LogicalEmptyRelation::new(node.produce_one_row))
     }
 
@@ -254,7 +262,9 @@ impl OptdPlanContext<'_> {
             LogicalPlan::Join(node) => self.into_optd_join(node)?.into_plan_node(),
             LogicalPlan::Filter(node) => self.into_optd_filter(node)?.into_plan_node(),
             LogicalPlan::CrossJoin(node) => self.into_optd_cross_join(node)?.into_plan_node(),
-            LogicalPlan::EmptyRelation(node) => self.into_optd_empty_relation(node)?.into_plan_node(),
+            LogicalPlan::EmptyRelation(node) => {
+                self.into_optd_empty_relation(node)?.into_plan_node()
+            }
             _ => bail!(
                 "unsupported plan node: {}",
                 format!("{:?}", node).split('\n').next().unwrap()

optd-datafusion-repr/src/plan_nodes.rs

@@ -2,14 +2,14 @@
 
 mod agg;
 mod apply;
+mod empty_relation;
 mod expr;
 mod filter;
 mod join;
 pub(super) mod macros;
 mod projection;
 mod scan;
 mod sort;
-mod empty_relation;
 
 use std::sync::Arc;
 
@@ -20,6 +20,7 @@ use optd_core::{
 
 pub use agg::{LogicalAgg, PhysicalAgg};
 pub use apply::{ApplyType, LogicalApply};
+pub use empty_relation::{LogicalEmptyRelation, PhysicalEmptyRelation};
 pub use expr::{
     BinOpExpr, BinOpType, ColumnRefExpr, ConstantExpr, ConstantType, ExprList, FuncExpr, FuncType,
     LogOpExpr, LogOpType, SortOrderExpr, SortOrderType, UnOpExpr, UnOpType,
@@ -30,7 +31,6 @@ use pretty_xmlish::{Pretty, PrettyConfig};
 pub use projection::{LogicalProjection, PhysicalProjection};
 pub use scan::{LogicalScan, PhysicalScan};
 pub use sort::{LogicalSort, PhysicalSort};
-pub use empty_relation::{LogicalEmptyRelation, PhysicalEmptyRelation};
 
 use crate::{
     adaptive::PhysicalCollector,

optd-datafusion-repr/src/plan_nodes/empty_relation.rs

@@ -40,7 +40,12 @@ impl LogicalEmptyRelation {
     }
 
     pub fn produce_one_row(&self) -> bool {
-        self.clone().into_rel_node().data.as_ref().unwrap().as_bool()
+        self.clone()
+            .into_rel_node()
+            .data
+            .as_ref()
+            .unwrap()
+            .as_bool()
     }
 }
 
@@ -73,6 +78,11 @@ impl PhysicalEmptyRelation {
     }
 
     pub fn produce_one_row(&self) -> bool {
-        self.clone().into_rel_node().data.as_ref().unwrap().as_bool()
+        self.clone()
+            .into_rel_node()
+            .data
+            .as_ref()
+            .unwrap()
+            .as_bool()
     }
 }

optd-datafusion-repr/src/properties/schema.rs

@@ -31,7 +31,7 @@ impl Into<DatafusionSchema> for Schema {
             ConstantType::Decimal => DataType::Float64,
             ConstantType::Utf8String => DataType::Utf8,
         };
-        let fields : Vec<_> = self
+        let fields: Vec<_> = self
             .0
             .iter()
             .enumerate()