refactor: Move optimizer into planner

src/query/service/src/sql/executor/expression_builder.rs

@@ -19,6 +19,7 @@ use common_exception::Result;
 use common_legacy_planners::Expression;
 
 use crate::sql::executor::util::format_field_name;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::AggregateFunction;
 use crate::sql::plans::AndExpr;
 use crate::sql::plans::BoundColumnRef;
@@ -28,7 +29,6 @@ use crate::sql::plans::ConstantExpr;
 use crate::sql::plans::FunctionCall;
 use crate::sql::plans::OrExpr;
 use crate::sql::plans::Scalar;
-use crate::sql::IndexType;
 use crate::sql::MetadataRef;
 
 pub trait FiledNameFormat {

src/query/service/src/sql/executor/format.rs

@@ -30,7 +30,7 @@ use super::Project;
 use super::Sort;
 use super::TableScan;
 use super::UnionAll;
-use crate::sql::IndexType;
+use crate::sql::planner::IndexType;
 use crate::sql::MetadataRef;
 use crate::sql::DUMMY_TABLE_INDEX;
 

src/query/service/src/sql/executor/physical_plan.rs

@@ -33,9 +33,9 @@ use super::physical_scalar::PhysicalScalar;
 use super::AggregateFunctionDesc;
 use super::SortDesc;
 use crate::sql::optimizer::ColumnSet;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::JoinType;
 use crate::sql::ColumnBinding;
-use crate::sql::IndexType;
 
 pub type ColumnID = String;
 

src/query/service/src/sql/executor/physical_scalar.rs

@@ -18,7 +18,7 @@ use common_datavalues::DataValue;
 use common_exception::Result;
 
 use super::ColumnID;
-use crate::sql::IndexType;
+use crate::sql::planner::IndexType;
 use crate::sql::MetadataRef;
 
 /// Serializable and desugared representation of `Scalar`.

src/query/service/src/sql/executor/util.rs

@@ -18,8 +18,8 @@ use once_cell::sync::Lazy;
 use regex::Regex;
 
 use crate::sql::optimizer::SExpr;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::Operator;
-use crate::sql::IndexType;
 
 /// Check if all plans in an expression are physical plans
 pub fn check_physical(expression: &SExpr) -> bool {

src/query/service/src/sql/mod.rs

@@ -12,17 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod common;
 pub mod executor;
 mod metrics;
-pub mod optimizer;
 mod parsers;
 mod plan_parser;
 pub mod planner;
 mod sql_parser;
 mod sql_statement;
 pub mod statements;
-pub use common::*;
 use common_legacy_parser::sql_common;
 use common_storages_util::table_option_keys;
 pub use plan_parser::PlanParser;

src/query/service/src/sql/planner/binder/bind_context.rs

@@ -28,9 +28,9 @@ use common_exception::Result;
 use parking_lot::RwLock;
 
 use super::AggregateInfo;
-use crate::sql::common::IndexType;
 use crate::sql::normalize_identifier;
 use crate::sql::optimizer::SExpr;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::Scalar;
 use crate::sql::NameResolutionContext;
 

src/query/service/src/sql/planner/binder/distinct.rs

@@ -20,14 +20,14 @@ use crate::sql::binder::Binder;
 use crate::sql::binder::ColumnBinding;
 use crate::sql::optimizer::SExpr;
 use crate::sql::planner::semantic::GroupingChecker;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::Aggregate;
 use crate::sql::plans::AggregateMode;
 use crate::sql::plans::BoundColumnRef;
 use crate::sql::plans::EvalScalar;
 use crate::sql::plans::Scalar;
 use crate::sql::plans::ScalarItem;
 use crate::sql::BindContext;
-use crate::sql::IndexType;
 
 impl Binder {
     pub(super) fn bind_distinct(

src/query/service/src/sql/planner/binder/project.rs

@@ -31,6 +31,7 @@ use crate::sql::planner::binder::Binder;
 use crate::sql::planner::binder::ColumnBinding;
 use crate::sql::planner::semantic::normalize_identifier;
 use crate::sql::planner::semantic::GroupingChecker;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::BoundColumnRef;
 use crate::sql::plans::EvalScalar;
 use crate::sql::plans::Project;
@@ -39,7 +40,6 @@ use crate::sql::plans::ScalarExpr;
 use crate::sql::plans::ScalarItem;
 use crate::sql::plans::SubqueryExpr;
 use crate::sql::plans::SubqueryType;
-use crate::sql::IndexType;
 
 impl<'a> Binder {
     pub(super) fn analyze_projection(

src/query/service/src/sql/planner/binder/sort.rs

@@ -30,6 +30,7 @@ use crate::sql::binder::ColumnBinding;
 use crate::sql::normalize_identifier;
 use crate::sql::optimizer::SExpr;
 use crate::sql::planner::semantic::GroupingChecker;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::AggregateFunction;
 use crate::sql::plans::AndExpr;
 use crate::sql::plans::BoundColumnRef;
@@ -43,7 +44,6 @@ use crate::sql::plans::ScalarItem;
 use crate::sql::plans::Sort;
 use crate::sql::plans::SortItem;
 use crate::sql::BindContext;
-use crate::sql::IndexType;
 use crate::sql::ScalarExpr;
 
 pub struct OrderItems<'a> {

src/query/service/src/sql/planner/binder/table.rs

@@ -40,11 +40,11 @@ use crate::sql::binder::Visibility;
 use crate::sql::optimizer::SExpr;
 use crate::sql::planner::semantic::normalize_identifier;
 use crate::sql::planner::semantic::TypeChecker;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::ConstantExpr;
 use crate::sql::plans::LogicalGet;
 use crate::sql::plans::Scalar;
 use crate::sql::BindContext;
-use crate::sql::IndexType;
 use crate::storages::view::view_table::QUERY;
 use crate::storages::NavigationPoint;
 use crate::storages::Table;

src/query/service/src/sql/planner/metadata.rs

@@ -21,8 +21,8 @@ use common_ast::ast::Literal;
 use common_datavalues::prelude::*;
 use parking_lot::RwLock;
 
-use crate::sql::common::IndexType;
 use crate::sql::optimizer::ColumnSet;
+use crate::sql::planner::IndexType;
 use crate::storages::Table;
 
 pub static DUMMY_TABLE_INDEX: IndexType = IndexType::MAX;

src/query/service/src/sql/planner/mod.rs

@@ -30,6 +30,7 @@ pub use crate::sql::planner::binder::BindContext;
 pub(crate) mod binder;
 mod format;
 mod metadata;
+pub mod optimizer;
 pub mod plans;
 mod semantic;
 
@@ -54,6 +55,8 @@ use crate::sessions::TableContext;
 const PROBE_INSERT_INITIAL_TOKENS: usize = 128;
 const PROBE_INSERT_MAX_TOKENS: usize = 128 * 8;
 
+pub type IndexType = usize;
+
 pub struct Planner {
     ctx: Arc<dyn TableContext>,
 }

src/query/service/src/sql/optimizer/cascades/mod.rs → src/query/service/src/sql/planner/optimizer/cascades/mod.rs

@@ -33,8 +33,8 @@ use crate::sql::optimizer::memo::Memo;
 use crate::sql::optimizer::rule::RuleSet;
 use crate::sql::optimizer::rule::TransformState;
 use crate::sql::optimizer::SExpr;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::Operator;
-use crate::sql::IndexType;
 
 /// A cascades-style search engine to enumerate possible alternations of a relational expression and
 /// find the optimal one.

src/query/service/src/sql/optimizer/cost/mod.rs → src/query/service/src/sql/planner/optimizer/cost/mod.rs

@@ -21,7 +21,7 @@ pub use cost_model::DefaultCostModel;
 
 use super::MExpr;
 use super::Memo;
-use crate::sql::IndexType;
+use crate::sql::planner::IndexType;
 
 #[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
 pub struct Cost(pub f64);

src/query/service/src/sql/optimizer/group.rs → src/query/service/src/sql/planner/optimizer/group.rs

@@ -16,7 +16,7 @@ use common_exception::Result;
 
 use crate::sql::optimizer::m_expr::MExpr;
 use crate::sql::optimizer::property::RelationalProperty;
-use crate::sql::IndexType;
+use crate::sql::planner::IndexType;
 
 /// `Group` is a set of logically equivalent relational expressions represented with `MExpr`.
 #[derive(Clone)]

src/query/service/src/sql/optimizer/heuristic/decorrelate.rs → src/query/service/src/sql/planner/optimizer/heuristic/decorrelate.rs

@@ -30,6 +30,7 @@ use crate::sql::optimizer::heuristic::subquery_rewriter::UnnestResult;
 use crate::sql::optimizer::ColumnSet;
 use crate::sql::optimizer::RelExpr;
 use crate::sql::optimizer::SExpr;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::Aggregate;
 use crate::sql::plans::AggregateFunction;
 use crate::sql::plans::AggregateMode;
@@ -54,7 +55,6 @@ use crate::sql::plans::SubqueryExpr;
 use crate::sql::plans::SubqueryType;
 use crate::sql::plans::UnionAll;
 use crate::sql::ColumnBinding;
-use crate::sql::IndexType;
 use crate::sql::MetadataRef;
 use crate::sql::ScalarExpr;
 

src/query/service/src/sql/optimizer/heuristic/subquery_rewriter.rs → src/query/service/src/sql/planner/optimizer/heuristic/subquery_rewriter.rs

@@ -28,6 +28,7 @@ use crate::sql::binder::Visibility;
 use crate::sql::optimizer::ColumnSet;
 use crate::sql::optimizer::RelExpr;
 use crate::sql::optimizer::SExpr;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::Aggregate;
 use crate::sql::plans::AggregateFunction;
 use crate::sql::plans::AggregateMode;
@@ -49,7 +50,6 @@ use crate::sql::plans::Scalar;
 use crate::sql::plans::ScalarItem;
 use crate::sql::plans::SubqueryExpr;
 use crate::sql::plans::SubqueryType;
-use crate::sql::IndexType;
 use crate::sql::MetadataRef;
 use crate::sql::ScalarExpr;
 

src/query/service/src/sql/optimizer/m_expr.rs → src/query/service/src/sql/planner/optimizer/m_expr.rs

@@ -21,9 +21,9 @@ use crate::sql::optimizer::pattern_extractor::PatternExtractor;
 use crate::sql::optimizer::rule::RulePtr;
 use crate::sql::optimizer::rule::TransformState;
 use crate::sql::optimizer::SExpr;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::Operator;
 use crate::sql::plans::RelOperator;
-use crate::sql::IndexType;
 
 /// `MExpr` is abbreviation of multiple expression, which is the representation of relational
 /// expressions inside `Memo`.

src/query/service/src/sql/optimizer/memo.rs → src/query/service/src/sql/planner/optimizer/memo.rs

@@ -22,8 +22,8 @@ use super::RelationalProperty;
 use crate::sql::optimizer::group::Group;
 use crate::sql::optimizer::m_expr::MExpr;
 use crate::sql::optimizer::s_expr::SExpr;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::RelOperator;
-use crate::sql::IndexType;
 
 /// `Memo` is a search space which memoize possible plans of a query.
 /// The plans inside `Memo` are organized with `Group`s.

src/query/service/src/sql/optimizer/property/mod.rs → src/query/service/src/sql/planner/optimizer/property/mod.rs

@@ -21,7 +21,7 @@ use std::collections::HashSet;
 pub use builder::RelExpr;
 pub use enforcer::require_property;
 
-use crate::sql::common::IndexType;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::Scalar;
 
 pub type ColumnSet = HashSet<IndexType>;

src/query/service/src/sql/optimizer/s_expr.rs → src/query/service/src/sql/planner/optimizer/s_expr.rs

@@ -18,24 +18,24 @@ use common_exception::Result;
 use super::RelationalProperty;
 use crate::sql::optimizer::rule::AppliedRules;
 use crate::sql::optimizer::rule::RuleID;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::Operator;
 use crate::sql::plans::PatternPlan;
 use crate::sql::plans::RelOp;
 use crate::sql::plans::RelOperator;
-use crate::sql::IndexType;
 
 /// `SExpr` is abbreviation of single expression, which is a tree of relational operators.
 #[derive(Clone, Debug)]
 pub struct SExpr {
-    pub(super) plan: RelOperator,
-    pub(super) children: Vec<SExpr>,
+    pub(in crate::sql) plan: RelOperator,
+    pub(in crate::sql) children: Vec<SExpr>,
 
-    pub(super) original_group: Option<IndexType>,
-    pub(super) rel_prop: Option<Box<RelationalProperty>>,
+    pub(in crate::sql) original_group: Option<IndexType>,
+    pub(in crate::sql) rel_prop: Option<Box<RelationalProperty>>,
 
     /// A bitmap to record applied rules on current SExpr, to prevent
     /// redundant transformations.
-    pub(super) applied_rules: AppliedRules,
+    pub(in crate::sql) applied_rules: AppliedRules,
 }
 
 impl SExpr {
@@ -139,12 +139,12 @@ impl SExpr {
     }
 
     /// Record the applied rule id in current SExpr
-    pub(super) fn apply_rule(&mut self, rule_id: &RuleID) {
+    pub(in crate::sql) fn apply_rule(&mut self, rule_id: &RuleID) {
         self.applied_rules.set(rule_id, true);
     }
 
     /// Check if a rule is applied for current SExpr
-    pub(super) fn applied_rule(&self, rule_id: &RuleID) -> bool {
+    pub(in crate::sql) fn applied_rule(&self, rule_id: &RuleID) -> bool {
         self.applied_rules.get(rule_id)
     }
 }

src/query/service/src/sql/planner/plans/eval_scalar.rs

@@ -19,13 +19,13 @@ use crate::sql::optimizer::PhysicalProperty;
 use crate::sql::optimizer::RelExpr;
 use crate::sql::optimizer::RelationalProperty;
 use crate::sql::optimizer::RequiredProperty;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::LogicalOperator;
 use crate::sql::plans::Operator;
 use crate::sql::plans::PhysicalOperator;
 use crate::sql::plans::RelOp;
 use crate::sql::plans::Scalar;
 use crate::sql::plans::ScalarExpr;
-use crate::sql::IndexType;
 
 /// Evaluate scalar expression
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]

src/query/service/src/sql/planner/plans/hash_join.rs

@@ -19,12 +19,12 @@ use crate::sql::optimizer::Distribution;
 use crate::sql::optimizer::PhysicalProperty;
 use crate::sql::optimizer::RelExpr;
 use crate::sql::optimizer::RequiredProperty;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::LogicalOperator;
 use crate::sql::plans::Operator;
 use crate::sql::plans::PhysicalOperator;
 use crate::sql::plans::RelOp;
 use crate::sql::plans::Scalar;
-use crate::sql::IndexType;
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct PhysicalHashJoin {

src/query/service/src/sql/planner/plans/logical_get.rs

@@ -19,13 +19,13 @@ use itertools::Itertools;
 use crate::sql::optimizer::ColumnSet;
 use crate::sql::optimizer::RelExpr;
 use crate::sql::optimizer::RelationalProperty;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::LogicalOperator;
 use crate::sql::plans::Operator;
 use crate::sql::plans::PhysicalOperator;
 use crate::sql::plans::RelOp;
 use crate::sql::plans::Scalar;
 use crate::sql::plans::SortItem;
-use crate::sql::IndexType;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Prewhere {

src/query/service/src/sql/planner/plans/logical_join.rs

@@ -20,12 +20,12 @@ use common_exception::Result;
 use super::ScalarExpr;
 use crate::sql::optimizer::RelExpr;
 use crate::sql::optimizer::RelationalProperty;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::LogicalOperator;
 use crate::sql::plans::Operator;
 use crate::sql::plans::PhysicalOperator;
 use crate::sql::plans::RelOp;
 use crate::sql::plans::Scalar;
-use crate::sql::IndexType;
 
 #[derive(Clone, Debug, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 pub enum JoinType {

src/query/service/src/sql/planner/plans/physical_scan.rs

@@ -23,13 +23,13 @@ use crate::sql::optimizer::Distribution;
 use crate::sql::optimizer::PhysicalProperty;
 use crate::sql::optimizer::RelExpr;
 use crate::sql::optimizer::RequiredProperty;
+use crate::sql::planner::IndexType;
 use crate::sql::plans::LogicalOperator;
 use crate::sql::plans::Operator;
 use crate::sql::plans::PhysicalOperator;
 use crate::sql::plans::RelOp;
 use crate::sql::plans::Scalar;
 use crate::sql::plans::SortItem;
-use crate::sql::IndexType;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct PhysicalScan {