style: format with nightly toolchain

Signed-off-by: Alex Chi <[email protected]>

Author: github-actions[bot]

optd-adaptive-demo/src/bin/optd-adaptive-three-join.rs

@@ -1,20 +1,17 @@
+use std::sync::Arc;
+
+use console::Style;
 use datafusion::error::Result;
 use datafusion::execution::context::{SessionConfig, SessionState};
 use datafusion::execution::runtime_env::{RuntimeConfig, RuntimeEnv};
 use datafusion::prelude::SessionContext;
-use datafusion_optd_cli::exec::exec_from_commands_collect;
-use datafusion_optd_cli::{
-    exec::exec_from_commands,
-    print_format::PrintFormat,
-    print_options::{MaxRows, PrintOptions},
-};
+use datafusion_optd_cli::exec::{exec_from_commands, exec_from_commands_collect};
+use datafusion_optd_cli::print_format::PrintFormat;
+use datafusion_optd_cli::print_options::{MaxRows, PrintOptions};
 use mimalloc::MiMalloc;
 use optd_datafusion_bridge::{DatafusionCatalog, OptdQueryPlanner};
 use optd_datafusion_repr::DatafusionOptimizer;
 use rand::{thread_rng, Rng};
-use std::sync::Arc;
-
-use console::Style;
 
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
@@ -247,8 +244,8 @@ async fn main() -> Result<()> {
         //             (select count(*) from t3) as t3cnt,
         //             (select count(*) from (select * from t1, t2 where t1v1 = t2v1)) as t1t2cnt,
         //             (select count(*) from (select * from t1, t3 where t1v2 = t3v2)) as t1t3cnt,
-        //             (select count(*) from (select * from t1, t2, t3 where t1v1 = t2v1 and t1v2 = t3v2)) as out_cnt;"#
-        //         .to_string()],
+        //             (select count(*) from (select * from t1, t2, t3 where t1v1 = t2v1 and t1v2 =
+        // t3v2)) as out_cnt;"#         .to_string()],
         // )
         // .await;
     }

optd-adaptive-demo/src/bin/optd-adaptive-tpch-q8.rs

@@ -1,18 +1,16 @@
+use std::sync::Arc;
+use std::time::Duration;
+
 use datafusion::error::Result;
 use datafusion::execution::context::{SessionConfig, SessionState};
 use datafusion::execution::runtime_env::{RuntimeConfig, RuntimeEnv};
 use datafusion::prelude::SessionContext;
-use datafusion_optd_cli::exec::{exec_from_commands_collect, exec_from_files};
-use datafusion_optd_cli::{
-    exec::exec_from_commands,
-    print_format::PrintFormat,
-    print_options::{MaxRows, PrintOptions},
-};
+use datafusion_optd_cli::exec::{exec_from_commands, exec_from_commands_collect, exec_from_files};
+use datafusion_optd_cli::print_format::PrintFormat;
+use datafusion_optd_cli::print_options::{MaxRows, PrintOptions};
 use mimalloc::MiMalloc;
 use optd_datafusion_bridge::{DatafusionCatalog, OptdQueryPlanner};
 use optd_datafusion_repr::DatafusionOptimizer;
-use std::sync::Arc;
-use std::time::Duration;
 
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;

optd-core/src/cascades/memo.rs

@@ -1,24 +1,21 @@
-use std::{
-    collections::{hash_map::Entry, HashMap, HashSet},
-    sync::Arc,
-};
+use std::any::Any;
+use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
 
 use anyhow::{bail, Context, Result};
 use itertools::Itertools;
-use std::any::Any;
 use tracing::trace;
 
-use crate::{
-    cost::{Cost, Statistics},
-    nodes::{ArcPlanNode, ArcPredNode, NodeType, PlanNode, PlanNodeOrGroup},
-    property::PropertyBuilderAny,
-};
-
 use super::optimizer::{ExprId, GroupId, PredId};
+use crate::cost::{Cost, Statistics};
+use crate::nodes::{ArcPlanNode, ArcPredNode, NodeType, PlanNode, PlanNodeOrGroup};
+use crate::property::PropertyBuilderAny;
 
 pub type ArcMemoPlanNode<T> = Arc<MemoPlanNode<T>>;
 
-/// The RelNode representation in the memo table. Store children as group IDs. Equivalent to MExpr in Columbia/Cascades.
+/// The RelNode representation in the memo table. Store children as group IDs. Equivalent to MExpr
+/// in Columbia/Cascades.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct MemoPlanNode<T: NodeType> {
     pub typ: T,
@@ -92,12 +89,13 @@ pub struct Group {
 
 /// Trait for memo table implementations.
 pub trait Memo<T: NodeType>: 'static + Send + Sync {
-    /// Add an expression to the memo table. If the expression already exists, it will return the existing group id and
-    /// expr id. Otherwise, a new group and expr will be created.
+    /// Add an expression to the memo table. If the expression already exists, it will return the
+    /// existing group id and expr id. Otherwise, a new group and expr will be created.
     fn add_new_expr(&mut self, rel_node: ArcPlanNode<T>) -> (GroupId, ExprId);
 
-    /// Add a new expression to an existing gruop. If the expression is a group, it will merge the two groups. Otherwise,
-    /// it will add the expression to the group. Returns the expr id if the expression is not a group.
+    /// Add a new expression to an existing gruop. If the expression is a group, it will merge the
+    /// two groups. Otherwise, it will add the expression to the group. Returns the expr id if
+    /// the expression is not a group.
     fn add_expr_to_group(
         &mut self,
         rel_node: PlanNodeOrGroup<T>,
@@ -126,8 +124,8 @@ pub trait Memo<T: NodeType>: 'static + Send + Sync {
     /// Update the group info.
     fn update_group_info(&mut self, group_id: GroupId, group_info: GroupInfo);
 
-    /// Estimated plan space for the memo table, only useful when plan exploration budget is enabled.
-    /// Returns number of expressions in the memo table.
+    /// Estimated plan space for the memo table, only useful when plan exploration budget is
+    /// enabled. Returns number of expressions in the memo table.
     fn estimated_plan_space(&self) -> usize;
 
     // The below functions can be overwritten by the memo table implementation if there
@@ -155,15 +153,17 @@ pub trait Memo<T: NodeType>: 'static + Send + Sync {
         get_best_group_binding_inner(self, group_id, &mut post_process)
     }
 
-    /// Get all bindings of a predicate group. Will panic if the group contains more than one bindings. Note that we
-    /// are currently in the refactor process of having predicates as a separate entity. If the representation stores
-    /// predicates in the rel node children, the repr should use this function to get the predicate binding. Otherwise,
-    /// use `ger_pred` for those predicates stored within the `predicates` field.
+    /// Get all bindings of a predicate group. Will panic if the group contains more than one
+    /// bindings. Note that we are currently in the refactor process of having predicates as a
+    /// separate entity. If the representation stores predicates in the rel node children, the
+    /// repr should use this function to get the predicate binding. Otherwise, use `ger_pred`
+    /// for those predicates stored within the `predicates` field.
     fn get_predicate_binding(&self, group_id: GroupId) -> Option<ArcPlanNode<T>> {
         get_predicate_binding_group_inner(self, group_id, true)
     }
 
-    /// Get all bindings of a predicate group. Returns None if the group contains zero or more than one bindings.
+    /// Get all bindings of a predicate group. Returns None if the group contains zero or more than
+    /// one bindings.
     fn try_get_predicate_binding(&self, group_id: GroupId) -> Option<ArcPlanNode<T>> {
         get_predicate_binding_group_inner(self, group_id, false)
     }
@@ -381,21 +381,24 @@ impl<T: NodeType> NaiveMemo<T> {
         }
     }
 
-    /// Get the next group id. Group id and expr id shares the same counter, so as to make it easier to debug...
+    /// Get the next group id. Group id and expr id shares the same counter, so as to make it easier
+    /// to debug...
     fn next_group_id(&mut self) -> GroupId {
         let id = self.group_expr_counter;
         self.group_expr_counter += 1;
         GroupId(id)
     }
 
-    /// Get the next expr id. Group id and expr id shares the same counter, so as to make it easier to debug...
+    /// Get the next expr id. Group id and expr id shares the same counter, so as to make it easier
+    /// to debug...
     fn next_expr_id(&mut self) -> ExprId {
         let id = self.group_expr_counter;
         self.group_expr_counter += 1;
         ExprId(id)
     }
 
-    /// Get the next pred id. Group id and expr id shares the same counter, so as to make it easier to debug...
+    /// Get the next pred id. Group id and expr id shares the same counter, so as to make it easier
+    /// to debug...
     fn next_pred_id(&mut self) -> PredId {
         let id = self.group_expr_counter;
         self.group_expr_counter += 1;
@@ -487,16 +490,18 @@ impl<T: NodeType> NaiveMemo<T> {
                         .insert(*expr_id, Arc::new(new_expr.clone()));
                     self.expr_node_to_expr_id.remove(&old_expr);
                     if let Some(dup_expr) = self.expr_node_to_expr_id.get(&new_expr) {
-                        // If new_expr == some_other_old_expr in the memo table, unless they belong to the same group,
-                        // we should merge the two groups. This should not happen. We should simply drop this expression.
+                        // If new_expr == some_other_old_expr in the memo table, unless they belong
+                        // to the same group, we should merge the two
+                        // groups. This should not happen. We should simply drop this expression.
                         let dup_group_id = self.expr_id_to_group_id[dup_expr];
                         if dup_group_id != *group_id {
                             pending_recursive_merge.push((dup_group_id, *group_id));
                         }
                         self.expr_id_to_expr_node.remove(expr_id);
                         self.expr_id_to_group_id.remove(expr_id);
                         self.dup_expr_mapping.insert(*expr_id, *dup_expr);
-                        new_expr_list.insert(*dup_expr); // adding this temporarily -- should be removed once recursive merge finishes
+                        new_expr_list.insert(*dup_expr); // adding this temporarily -- should be
+                                                         // removed once recursive merge finishes
                     } else {
                         self.expr_node_to_expr_id.insert(new_expr, *expr_id);
                         new_expr_list.insert(*expr_id);
@@ -509,7 +514,8 @@ impl<T: NodeType> NaiveMemo<T> {
             group.group_exprs = new_expr_list;
         }
         for (merge_from, merge_into) in pending_recursive_merge {
-            // We need to reduce because each merge would probably invalidate some groups in the last loop iteration.
+            // We need to reduce because each merge would probably invalidate some groups in the
+            // last loop iteration.
             let merge_from = self.reduce_group(merge_from);
             let merge_into = self.reduce_group(merge_into);
             self.merge_group_inner(merge_into, merge_from);
@@ -526,9 +532,11 @@ impl<T: NodeType> NaiveMemo<T> {
             .iter()
             .map(|child| {
                 match child {
-                    PlanNodeOrGroup::Group(group) => self.reduce_group(*group), // TODO: can I remove reduce?
+                    // TODO: can I remove reduce?
+                    PlanNodeOrGroup::Group(group) => self.reduce_group(*group),
                     PlanNodeOrGroup::PlanNode(child) => {
-                        // No merge / modification to the memo should occur for the following operation
+                        // No merge / modification to the memo should occur for the following
+                        // operation
                         let (group, _) = self
                             .add_new_group_expr_inner(child.clone(), None)
                             .expect("should not trigger merge group");
@@ -569,8 +577,8 @@ impl<T: NodeType> NaiveMemo<T> {
         Ok((group_id, expr_id))
     }
 
-    /// This is inefficient: usually the optimizer should have a MemoRef instead of passing the full rel node. Should
-    /// be only used for debugging purpose.
+    /// This is inefficient: usually the optimizer should have a MemoRef instead of passing the full
+    /// rel node. Should be only used for debugging purpose.
     #[cfg(test)]
     pub(crate) fn get_expr_info(&self, rel_node: ArcPlanNode<T>) -> (GroupId, ExprId) {
         let children_group_ids = rel_node
@@ -662,9 +670,8 @@ impl<T: NodeType> NaiveMemo<T> {
 #[cfg(test)]
 mod tests {
 
-    use crate::nodes::{PredNode, Value};
-
     use super::*;
+    use crate::nodes::{PredNode, Value};
 
     #[derive(Debug, Clone, PartialEq, Eq, Hash)]
     enum MemoTestRelTyp {

optd-core/src/cascades/optimizer.rs

@@ -1,26 +1,21 @@
-use std::{
-    collections::{BTreeSet, HashMap, HashSet, VecDeque},
-    fmt::Display,
-    sync::Arc,
-};
+use std::collections::{BTreeSet, HashMap, HashSet, VecDeque};
+use std::fmt::Display;
+use std::sync::Arc;
 
 use anyhow::Result;
 use tracing::trace;
 
-use crate::{
-    cascades::memo::Winner,
-    cost::CostModel,
-    nodes::{ArcPlanNode, ArcPredNode, NodeType, PlanNodeMeta, PlanNodeMetaMap, PlanNodeOrGroup},
-    optimizer::Optimizer,
-    property::{PropertyBuilder, PropertyBuilderAny},
-    rules::RuleWrapper,
-};
-
-use super::{
-    memo::{ArcMemoPlanNode, GroupInfo, Memo},
-    tasks::OptimizeGroupTask,
-    NaiveMemo, Task,
+use super::memo::{ArcMemoPlanNode, GroupInfo, Memo};
+use super::tasks::OptimizeGroupTask;
+use super::{NaiveMemo, Task};
+use crate::cascades::memo::Winner;
+use crate::cost::CostModel;
+use crate::nodes::{
+    ArcPlanNode, ArcPredNode, NodeType, PlanNodeMeta, PlanNodeMetaMap, PlanNodeOrGroup,
 };
+use crate::optimizer::Optimizer;
+use crate::property::{PropertyBuilder, PropertyBuilderAny};
+use crate::rules::RuleWrapper;
 
 pub type RuleId = usize;
 
@@ -55,8 +50,9 @@ pub struct CascadesOptimizer<T: NodeType, M: Memo<T> = NaiveMemo<T>> {
     pub prop: OptimizerProperties,
 }
 
-/// `RelNode` only contains the representation of the plan nodes. Sometimes, we need more context, i.e., group id and
-/// expr id, during the optimization phase. All these information are collected in this struct.
+/// `RelNode` only contains the representation of the plan nodes. Sometimes, we need more context,
+/// i.e., group id and expr id, during the optimization phase. All these information are collected
+/// in this struct.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Default, Hash)]
 pub struct RelNodeContext {
     pub group_id: GroupId,

optd-core/src/cascades/tasks.rs

@@ -1,8 +1,7 @@
 use anyhow::Result;
 
-use crate::nodes::NodeType;
-
 use super::{CascadesOptimizer, Memo};
+use crate::nodes::NodeType;
 
 mod apply_rule;
 mod explore_group;

optd-core/src/cascades/tasks/apply_rule.rs

@@ -4,18 +4,13 @@ use anyhow::Result;
 use itertools::Itertools;
 use tracing::trace;
 
-use crate::{
-    cascades::{
-        memo::ArcMemoPlanNode,
-        optimizer::{CascadesOptimizer, ExprId, RuleId},
-        tasks::{OptimizeExpressionTask, OptimizeInputsTask},
-        GroupId, Memo,
-    },
-    nodes::{ArcPlanNode, NodeType, PlanNode, PlanNodeOrGroup},
-    rules::{OptimizeType, RuleMatcher},
-};
-
 use super::Task;
+use crate::cascades::memo::ArcMemoPlanNode;
+use crate::cascades::optimizer::{CascadesOptimizer, ExprId, RuleId};
+use crate::cascades::tasks::{OptimizeExpressionTask, OptimizeInputsTask};
+use crate::cascades::{GroupId, Memo};
+use crate::nodes::{ArcPlanNode, NodeType, PlanNode, PlanNodeOrGroup};
+use crate::rules::{OptimizeType, RuleMatcher};
 
 pub struct ApplyRuleTask {
     rule_id: RuleId,

optd-core/src/cascades/tasks/explore_group.rs

@@ -1,16 +1,11 @@
 use anyhow::Result;
 use tracing::trace;
 
-use crate::{
-    cascades::{
-        optimizer::{CascadesOptimizer, GroupId},
-        tasks::OptimizeExpressionTask,
-        Memo,
-    },
-    nodes::NodeType,
-};
-
 use super::Task;
+use crate::cascades::optimizer::{CascadesOptimizer, GroupId};
+use crate::cascades::tasks::OptimizeExpressionTask;
+use crate::cascades::Memo;
+use crate::nodes::NodeType;
 
 pub struct ExploreGroupTask {
     group_id: GroupId,

optd-core/src/cascades/tasks/optimize_expression.rs

@@ -1,17 +1,12 @@
 use anyhow::Result;
 use tracing::trace;
 
-use crate::{
-    cascades::{
-        optimizer::{CascadesOptimizer, ExprId},
-        tasks::{ApplyRuleTask, ExploreGroupTask},
-        Memo,
-    },
-    nodes::NodeType,
-    rules::RuleMatcher,
-};
-
 use super::Task;
+use crate::cascades::optimizer::{CascadesOptimizer, ExprId};
+use crate::cascades::tasks::{ApplyRuleTask, ExploreGroupTask};
+use crate::cascades::Memo;
+use crate::nodes::NodeType;
+use crate::rules::RuleMatcher;
 
 pub struct OptimizeExpressionTask {
     expr_id: ExprId,

optd-core/src/cascades/tasks/optimize_group.rs

@@ -1,16 +1,12 @@
 use anyhow::Result;
 use tracing::trace;
 
-use crate::{
-    cascades::{
-        optimizer::GroupId,
-        tasks::{optimize_expression::OptimizeExpressionTask, OptimizeInputsTask},
-        CascadesOptimizer, Memo,
-    },
-    nodes::NodeType,
-};
-
 use super::Task;
+use crate::cascades::optimizer::GroupId;
+use crate::cascades::tasks::optimize_expression::OptimizeExpressionTask;
+use crate::cascades::tasks::OptimizeInputsTask;
+use crate::cascades::{CascadesOptimizer, Memo};
+use crate::nodes::NodeType;
 
 pub struct OptimizeGroupTask {
     group_id: GroupId,