diff --git a/Cargo.lock b/Cargo.lock
index 10524f93931cb..8a872e97027c9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2032,6 +2032,9 @@ dependencies = [
  "dashmap",
  "globiter",
  "itertools",
+ "num",
+ "num-derive",
+ "num-traits",
  "once_cell",
  "opendal",
  "ordered-float 3.4.0",
diff --git a/src/query/sql/Cargo.toml b/src/query/sql/Cargo.toml
index 4849565c0ed48..c9161452347e9 100644
--- a/src/query/sql/Cargo.toml
+++ b/src/query/sql/Cargo.toml
@@ -46,6 +46,8 @@ chrono = { workspace = true }
 dashmap = "5.4"
 globiter = "0.1"
 itertools = "0.10.5"
+num-derive = "0.3.3"
+num-traits = "0.2.15"
 once_cell = "1.15.0"
 opendal = { workspace = true }
 ordered-float = { workspace = true }
diff --git a/src/query/sql/src/planner/optimizer/cascades/cascade.rs b/src/query/sql/src/planner/optimizer/cascades/cascade.rs
index 057040e962b2f..a0a9be82ba340 100644
--- a/src/query/sql/src/planner/optimizer/cascades/cascade.rs
+++ b/src/query/sql/src/planner/optimizer/cascades/cascade.rs
@@ -18,9 +18,8 @@ use std::sync::Arc;
 use common_catalog::table_context::TableContext;
 use common_exception::ErrorCode;
 use common_exception::Result;
-use roaring::RoaringBitmap;
 
-use super::explore_rules::calc_explore_rule_set;
+use super::explore_rules::get_explore_rule_set;
 use crate::optimizer::cascades::scheduler::Scheduler;
 use crate::optimizer::cascades::tasks::OptimizeGroupTask;
 use crate::optimizer::cascades::tasks::Task;
@@ -30,36 +29,36 @@ use crate::optimizer::cost::DefaultCostModel;
 use crate::optimizer::format::display_memo;
 use crate::optimizer::memo::Memo;
 use crate::optimizer::rule::TransformResult;
+use crate::optimizer::RuleSet;
 use crate::optimizer::SExpr;
 use crate::IndexType;
+use crate::MetadataRef;
 
 /// A cascades-style search engine to enumerate possible alternations of a relational expression and
 /// find the optimal one.
 pub struct CascadesOptimizer {
-    pub memo: Memo,
-    pub explore_rule_set: roaring::RoaringBitmap,
-
-    pub cost_model: Box<dyn CostModel>,
-
+    pub(crate) memo: Memo,
+    pub(crate) cost_model: Box<dyn CostModel>,
     /// group index -> best cost context
-    pub best_cost_map: HashMap<IndexType, CostContext>,
-    _ctx: Arc<dyn TableContext>,
+    pub(crate) best_cost_map: HashMap<IndexType, CostContext>,
+    pub(crate) explore_rule_set: RuleSet,
+    pub(crate) metadata: MetadataRef,
 }
 
 impl CascadesOptimizer {
-    pub fn create(ctx: Arc<dyn TableContext>) -> Result<Self> {
+    pub fn create(ctx: Arc<dyn TableContext>, metadata: MetadataRef) -> Result<Self> {
         let enable_bushy_join = ctx.get_settings().get_enable_bushy_join()? != 0;
         let explore_rule_set = if ctx.get_settings().get_enable_cbo()? {
-            calc_explore_rule_set(enable_bushy_join)
+            get_explore_rule_set(enable_bushy_join)
         } else {
-            RoaringBitmap::new()
+            RuleSet::create()
         };
         Ok(CascadesOptimizer {
             memo: Memo::create(),
             cost_model: Box::new(DefaultCostModel),
             best_cost_map: HashMap::new(),
-            _ctx: ctx,
             explore_rule_set,
+            metadata,
         })
     }
 
diff --git a/src/query/sql/src/planner/optimizer/cascades/explore_rules.rs b/src/query/sql/src/planner/optimizer/cascades/explore_rules.rs
index 5e004940db883..a60bb32b6981f 100644
--- a/src/query/sql/src/planner/optimizer/cascades/explore_rules.rs
+++ b/src/query/sql/src/planner/optimizer/cascades/explore_rules.rs
@@ -12,27 +12,30 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use roaring::RoaringBitmap;
-
 use crate::optimizer::RuleID;
+use crate::optimizer::RuleSet;
 
-pub fn calc_explore_rule_set(enable_bushy_join: bool) -> RoaringBitmap {
+pub fn get_explore_rule_set(enable_bushy_join: bool) -> RuleSet {
     if enable_bushy_join {
-        calc_join_rule_set_rs_b2()
+        rule_set_rs_b2()
     } else {
-        calc_join_rule_set_rs_l1()
+        rule_set_rs_l1()
     }
 }
 
 /// Get rule set of join order RS-B2, which may generate bushy trees.
 /// Read paper "The Complexity of Transformation-Based Join Enumeration" for more details.
-fn calc_join_rule_set_rs_b2() -> RoaringBitmap {
-    (RuleID::CommuteJoin as u32..RuleID::CommuteJoinBaseTable as u32).collect::<RoaringBitmap>()
+fn rule_set_rs_b2() -> RuleSet {
+    RuleSet::create_with_ids(vec![
+        RuleID::CommuteJoin,
+        RuleID::LeftAssociateJoin,
+        RuleID::RightAssociateJoin,
+        RuleID::ExchangeJoin,
+    ])
 }
 
 /// Get rule set of join order RS-L1, which will only generate left-deep trees.
 /// Read paper "The Complexity of Transformation-Based Join Enumeration" for more details.
-fn calc_join_rule_set_rs_l1() -> RoaringBitmap {
-    (RuleID::CommuteJoinBaseTable as u32..RuleID::RightExchangeJoin as u32)
-        .collect::<RoaringBitmap>()
+fn rule_set_rs_l1() -> RuleSet {
+    RuleSet::create_with_ids(vec![RuleID::CommuteJoinBaseTable, RuleID::LeftExchangeJoin])
 }
diff --git a/src/query/sql/src/planner/optimizer/cascades/tasks/apply_rule.rs b/src/query/sql/src/planner/optimizer/cascades/tasks/apply_rule.rs
index 401a0c7f09fde..b188295c97014 100644
--- a/src/query/sql/src/planner/optimizer/cascades/tasks/apply_rule.rs
+++ b/src/query/sql/src/planner/optimizer/cascades/tasks/apply_rule.rs
@@ -58,7 +58,7 @@ impl ApplyRuleTask {
         let group = optimizer.memo.group(self.target_group_index)?;
         let m_expr = group.m_expr(self.m_expr_index)?;
         let mut state = TransformResult::new();
-        let rule = RuleFactory::create().create_rule(self.rule_id, None)?;
+        let rule = RuleFactory::create_rule(self.rule_id, optimizer.metadata.clone())?;
         m_expr.apply_rule(&optimizer.memo, &rule, &mut state)?;
         optimizer.insert_from_transform_state(self.target_group_index, state)?;
 
diff --git a/src/query/sql/src/planner/optimizer/cascades/tasks/explore_expr.rs b/src/query/sql/src/planner/optimizer/cascades/tasks/explore_expr.rs
index a4859bf3a1d0e..d42315acd19f6 100644
--- a/src/query/sql/src/planner/optimizer/cascades/tasks/explore_expr.rs
+++ b/src/query/sql/src/planner/optimizer/cascades/tasks/explore_expr.rs
@@ -22,10 +22,6 @@ use super::Task;
 use crate::optimizer::cascades::scheduler::Scheduler;
 use crate::optimizer::cascades::tasks::SharedCounter;
 use crate::optimizer::cascades::CascadesOptimizer;
-use crate::optimizer::RuleID;
-use crate::optimizer::RULE_FACTORY;
-use crate::plans::Operator;
-use crate::plans::RelOperator;
 use crate::IndexType;
 
 #[derive(Clone, Copy, Debug)]
@@ -144,18 +140,6 @@ impl ExploreExprTask {
         }
     }
 
-    fn calc_operator_rule_set(
-        &self,
-        optimizer: &CascadesOptimizer,
-        operator: &RelOperator,
-    ) -> roaring::RoaringBitmap {
-        unsafe {
-            operator.exploration_candidate_rules()
-                & (&RULE_FACTORY.exploration_rules)
-                & (&optimizer.explore_rule_set)
-        }
-    }
-
     fn explore_self(
         &mut self,
         optimizer: &mut CascadesOptimizer,
@@ -165,11 +149,11 @@ impl ExploreExprTask {
             .memo
             .group(self.group_index)?
             .m_expr(self.m_expr_index)?;
-        let rule_set = self.calc_operator_rule_set(optimizer, &m_expr.plan);
+        let rule_set = &optimizer.explore_rule_set;
 
         for rule_id in rule_set.iter() {
             let apply_rule_task = ApplyRuleTask::with_parent(
-                unsafe { std::mem::transmute::<u8, RuleID>(rule_id as u8) },
+                rule_id,
                 m_expr.group_index,
                 m_expr.index,
                 &self.ref_count,
diff --git a/src/query/sql/src/planner/optimizer/heuristic/heuristic.rs b/src/query/sql/src/planner/optimizer/heuristic/heuristic.rs
index b498a99641f01..a35e1af793a7b 100644
--- a/src/query/sql/src/planner/optimizer/heuristic/heuristic.rs
+++ b/src/query/sql/src/planner/optimizer/heuristic/heuristic.rs
@@ -20,14 +20,11 @@ use once_cell::sync::Lazy;
 
 use super::prune_unused_columns::UnusedColumnPruner;
 use crate::optimizer::heuristic::decorrelate::decorrelate_subquery;
-use crate::optimizer::rule::RulePtr;
 use crate::optimizer::rule::TransformResult;
 use crate::optimizer::ColumnSet;
+use crate::optimizer::RuleFactory;
 use crate::optimizer::RuleID;
 use crate::optimizer::SExpr;
-use crate::optimizer::RULE_FACTORY;
-use crate::plans::Operator;
-use crate::plans::RelOperator;
 use crate::BindContext;
 use crate::MetadataRef;
 
@@ -118,27 +115,13 @@ impl HeuristicOptimizer {
         Ok(result)
     }
 
-    fn calc_operator_rule_set(&self, operator: &RelOperator) -> roaring::RoaringBitmap {
-        unsafe { operator.transformation_candidate_rules() & (&RULE_FACTORY.transformation_rules) }
-    }
-
-    fn get_rule(&self, rule_id: u32) -> Result<RulePtr> {
-        unsafe {
-            RULE_FACTORY.create_rule(
-                DEFAULT_REWRITE_RULES[rule_id as usize],
-                Some(self.metadata.clone()),
-            )
-        }
-    }
-
     /// Try to apply the rules to the expression.
     /// Return the final result that no rule can be applied.
     fn apply_transform_rules(&self, s_expr: &SExpr) -> Result<SExpr> {
         let mut s_expr = s_expr.clone();
-        let rule_set = self.calc_operator_rule_set(&s_expr.plan);
 
-        for rule_id in rule_set.iter() {
-            let rule = self.get_rule(rule_id)?;
+        for rule_id in DEFAULT_REWRITE_RULES.iter() {
+            let rule = RuleFactory::create_rule(*rule_id, self.metadata.clone())?;
             let mut state = TransformResult::new();
             if s_expr.match_pattern(rule.pattern()) && !s_expr.applied_rule(&rule.id()) {
                 s_expr.set_applied_rule(&rule.id());
diff --git a/src/query/sql/src/planner/optimizer/mod.rs b/src/query/sql/src/planner/optimizer/mod.rs
index 81caf6244e522..6caf05ed70c33 100644
--- a/src/query/sql/src/planner/optimizer/mod.rs
+++ b/src/query/sql/src/planner/optimizer/mod.rs
@@ -43,5 +43,4 @@ pub use rule::try_push_down_filter_join;
 pub use rule::RuleFactory;
 pub use rule::RuleID;
 pub use rule::RuleSet;
-pub use rule::RULE_FACTORY;
 pub use s_expr::SExpr;
diff --git a/src/query/sql/src/planner/optimizer/optimizer.rs b/src/query/sql/src/planner/optimizer/optimizer.rs
index 1e64ef7193a9f..b75d74d1a1823 100644
--- a/src/query/sql/src/planner/optimizer/optimizer.rs
+++ b/src/query/sql/src/planner/optimizer/optimizer.rs
@@ -147,10 +147,10 @@ pub fn optimize_query(
 ) -> Result<SExpr> {
     let contains_local_table_scan = contains_local_table_scan(&s_expr, &metadata);
 
-    let mut heuristic = HeuristicOptimizer::new(ctx.clone(), bind_context, metadata);
+    let mut heuristic = HeuristicOptimizer::new(ctx.clone(), bind_context, metadata.clone());
     let mut result = heuristic.optimize(s_expr)?;
 
-    let mut cascades = CascadesOptimizer::create(ctx.clone())?;
+    let mut cascades = CascadesOptimizer::create(ctx.clone(), metadata)?;
     result = cascades.optimize(result)?;
 
     // So far, we don't have ability to execute distributed query
@@ -178,10 +178,10 @@ fn get_optimized_memo(
     metadata: MetadataRef,
     bind_context: Box<BindContext>,
 ) -> Result<(Memo, HashMap<IndexType, CostContext>)> {
-    let mut heuristic = HeuristicOptimizer::new(ctx.clone(), bind_context, metadata);
+    let mut heuristic = HeuristicOptimizer::new(ctx.clone(), bind_context, metadata.clone());
     let result = heuristic.optimize(s_expr)?;
 
-    let mut cascades = CascadesOptimizer::create(ctx)?;
+    let mut cascades = CascadesOptimizer::create(ctx, metadata)?;
     cascades.optimize(result)?;
     Ok((cascades.memo, cascades.best_cost_map))
 }
diff --git a/src/query/sql/src/planner/optimizer/rule/factory.rs b/src/query/sql/src/planner/optimizer/rule/factory.rs
index c35d45ca9b277..499d313306fc4 100644
--- a/src/query/sql/src/planner/optimizer/rule/factory.rs
+++ b/src/query/sql/src/planner/optimizer/rule/factory.rs
@@ -13,8 +13,6 @@
 // limitations under the License.
 
 use common_exception::Result;
-use once_cell::sync::Lazy;
-use roaring::RoaringBitmap;
 
 use super::rewrite::RuleEliminateEvalScalar;
 use super::rewrite::RuleFoldCountAggregate;
@@ -49,36 +47,16 @@ use crate::optimizer::rule::RuleID;
 use crate::optimizer::rule::RulePtr;
 use crate::MetadataRef;
 
-// read only, so thread safe
-pub static mut RULE_FACTORY: Lazy<RuleFactory> = Lazy::new(RuleFactory::create);
-
-pub struct RuleFactory {
-    pub transformation_rules: roaring::RoaringBitmap,
-    pub exploration_rules: roaring::RoaringBitmap,
-}
+pub struct RuleFactory;
 
 impl RuleFactory {
-    pub fn create() -> Self {
-        RuleFactory {
-            transformation_rules: (RuleID::NormalizeScalarFilter as u32
-                ..RuleID::CommuteJoin as u32)
-                .collect::<RoaringBitmap>(),
-            exploration_rules: (RuleID::CommuteJoin as u32..(RuleID::RightExchangeJoin as u32) + 1)
-                .collect::<RoaringBitmap>(),
-        }
-    }
-
-    pub fn create_rule(&self, id: RuleID, metadata: Option<MetadataRef>) -> Result<RulePtr> {
+    pub fn create_rule(id: RuleID, metadata: MetadataRef) -> Result<RulePtr> {
         match id {
             RuleID::EliminateEvalScalar => Ok(Box::new(RuleEliminateEvalScalar::new())),
             RuleID::PushDownFilterUnion => Ok(Box::new(RulePushDownFilterUnion::new())),
             RuleID::PushDownFilterEvalScalar => Ok(Box::new(RulePushDownFilterEvalScalar::new())),
-            RuleID::PushDownFilterJoin => {
-                Ok(Box::new(RulePushDownFilterJoin::new(metadata.unwrap())))
-            }
-            RuleID::PushDownFilterScan => {
-                Ok(Box::new(RulePushDownFilterScan::new(metadata.unwrap())))
-            }
+            RuleID::PushDownFilterJoin => Ok(Box::new(RulePushDownFilterJoin::new(metadata))),
+            RuleID::PushDownFilterScan => Ok(Box::new(RulePushDownFilterScan::new(metadata))),
             RuleID::PushDownFilterSort => Ok(Box::new(RulePushDownFilterSort::new())),
             RuleID::PushDownLimitUnion => Ok(Box::new(RulePushDownLimitUnion::new())),
             RuleID::PushDownLimitScan => Ok(Box::new(RulePushDownLimitScan::new())),
@@ -104,7 +82,7 @@ impl RuleFactory {
             RuleID::LeftExchangeJoin => Ok(Box::new(RuleLeftExchangeJoin::new())),
             RuleID::RightExchangeJoin => Ok(Box::new(RuleRightExchangeJoin::new())),
             RuleID::ExchangeJoin => Ok(Box::new(RuleExchangeJoin::new())),
-            RuleID::PushDownPrewhere => Ok(Box::new(RulePushDownPrewhere::new(metadata.unwrap()))),
+            RuleID::PushDownPrewhere => Ok(Box::new(RulePushDownPrewhere::new(metadata))),
         }
     }
 }
diff --git a/src/query/sql/src/planner/optimizer/rule/mod.rs b/src/query/sql/src/planner/optimizer/rule/mod.rs
index d635716a44194..32d994a667379 100644
--- a/src/query/sql/src/planner/optimizer/rule/mod.rs
+++ b/src/query/sql/src/planner/optimizer/rule/mod.rs
@@ -21,7 +21,6 @@ mod transform;
 mod transform_result;
 
 pub use factory::RuleFactory;
-pub use factory::RULE_FACTORY;
 pub use rewrite::try_push_down_filter_join;
 pub use rule::Rule;
 pub use rule::RuleID;
diff --git a/src/query/sql/src/planner/optimizer/rule/rule.rs b/src/query/sql/src/planner/optimizer/rule/rule.rs
index feb9c151813c5..6ee65621aac13 100644
--- a/src/query/sql/src/planner/optimizer/rule/rule.rs
+++ b/src/query/sql/src/planner/optimizer/rule/rule.rs
@@ -16,6 +16,8 @@ use std::fmt::Display;
 use std::fmt::Formatter;
 
 use common_exception::Result;
+use num_derive::FromPrimitive;
+use num_derive::ToPrimitive;
 
 use crate::optimizer::rule::TransformResult;
 use crate::optimizer::SExpr;
@@ -36,7 +38,7 @@ pub trait Rule {
 
 // If add a new rule, please add it to the operator's corresponding `transformation_candidate_rules`
 // Such as `PushDownFilterAggregate` is related to `Filter` operator.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, FromPrimitive, ToPrimitive)]
 pub enum RuleID {
     // Rewrite rules
     NormalizeScalarFilter,
diff --git a/src/query/sql/src/planner/optimizer/rule/rule_set.rs b/src/query/sql/src/planner/optimizer/rule/rule_set.rs
index 40ed6d496195d..1097ea20906a3 100644
--- a/src/query/sql/src/planner/optimizer/rule/rule_set.rs
+++ b/src/query/sql/src/planner/optimizer/rule/rule_set.rs
@@ -12,62 +12,59 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
-use std::collections::HashSet;
+use num_traits::FromPrimitive;
+use roaring::RoaringBitmap;
 
-use common_exception::ErrorCode;
-use common_exception::Result;
-
-use crate::optimizer::rule::factory::RuleFactory;
 use crate::optimizer::rule::RuleID;
-use crate::optimizer::rule::RulePtr;
 
 /// Set of `Rule`
+#[derive(Debug, Clone, PartialEq, Default)]
 pub struct RuleSet {
-    rules: HashMap<RuleID, RulePtr>,
+    rules: RoaringBitmap,
 }
 
 impl RuleSet {
     pub fn create() -> Self {
         RuleSet {
-            rules: HashMap::new(),
+            rules: RoaringBitmap::new(),
         }
     }
 
-    pub fn create_with_ids(ids: Vec<RuleID>) -> Result<Self> {
-        let factory = RuleFactory::create();
+    pub fn create_with_ids(ids: Vec<RuleID>) -> Self {
         let mut rule_set = Self::create();
         for id in ids {
-            if rule_set.contains(&id) {
-                return Err(ErrorCode::Internal(format!("Duplicated Rule: {id}",)));
-            }
-            rule_set.insert(factory.create_rule(id, None)?);
+            rule_set.rules.insert(id as u32);
         }
-
-        Ok(rule_set)
+        rule_set
     }
 
-    pub fn insert(&mut self, rule: RulePtr) {
-        self.rules.insert(rule.id(), rule);
+    pub fn insert(&mut self, id: RuleID) {
+        self.rules.insert(id as u32);
     }
 
     pub fn contains(&self, id: &RuleID) -> bool {
-        self.rules.contains_key(id)
+        self.rules.contains(*id as u32)
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = &RulePtr> {
-        self.rules.values()
+    pub fn remove(&mut self, id: &RuleID) {
+        self.rules.remove(*id as u32);
+    }
+
+    pub fn intersect(&self, other: &RuleSet) -> RuleSet {
+        let mut rule_set = Self::create();
+        rule_set.rules = self.rules.clone() & other.rules.clone();
+        rule_set
     }
 
-    pub fn get(&self, id: &RuleID) -> Option<&RulePtr> {
-        self.rules.get(id)
+    pub fn iter(&self) -> impl Iterator<Item = RuleID> + '_ {
+        self.rules.iter().map(|v| RuleID::from_u32(v).unwrap())
     }
 }
 
 /// A bitmap to store information about applied rules
-#[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[derive(Debug, Clone, PartialEq, Default)]
 pub struct AppliedRules {
-    rules: HashSet<RuleID>,
+    rules: RuleSet,
 }
 
 impl AppliedRules {
diff --git a/src/query/sql/src/planner/plans/aggregate.rs b/src/query/sql/src/planner/plans/aggregate.rs
index 439907a9c1e84..ed155784bd454 100644
--- a/src/query/sql/src/planner/plans/aggregate.rs
+++ b/src/query/sql/src/planner/plans/aggregate.rs
@@ -16,7 +16,6 @@ use std::sync::Arc;
 
 use common_catalog::table_context::TableContext;
 use common_exception::Result;
-use roaring::RoaringBitmap;
 
 use crate::optimizer::ColumnSet;
 use crate::optimizer::Distribution;
@@ -24,7 +23,6 @@ use crate::optimizer::PhysicalProperty;
 use crate::optimizer::RelExpr;
 use crate::optimizer::RelationalProperty;
 use crate::optimizer::RequiredProperty;
-use crate::optimizer::RuleID;
 use crate::optimizer::Statistics;
 use crate::plans::Operator;
 use crate::plans::RelOp;
@@ -81,13 +79,6 @@ impl Operator for Aggregate {
         RelOp::Aggregate
     }
 
-    fn transformation_candidate_rules(&self) -> roaring::RoaringBitmap {
-        let mut ret = RoaringBitmap::new();
-        ret.push(RuleID::SplitAggregate as u32);
-        ret.push(RuleID::FoldCountAggregate as u32);
-        ret
-    }
-
     fn derive_physical_prop(&self, rel_expr: &RelExpr) -> Result<PhysicalProperty> {
         rel_expr.derive_physical_prop_child(0)
     }
diff --git a/src/query/sql/src/planner/plans/dummy_table_scan.rs b/src/query/sql/src/planner/plans/dummy_table_scan.rs
index 773a97c34dc82..b96aff3d31766 100644
--- a/src/query/sql/src/planner/plans/dummy_table_scan.rs
+++ b/src/query/sql/src/planner/plans/dummy_table_scan.rs
@@ -16,7 +16,6 @@ use std::sync::Arc;
 
 use common_catalog::table_context::TableContext;
 use common_exception::Result;
-use roaring::RoaringBitmap;
 
 use super::Operator;
 use crate::optimizer::ColumnSet;
@@ -38,14 +37,6 @@ impl Operator for DummyTableScan {
         super::RelOp::DummyTableScan
     }
 
-    fn transformation_candidate_rules(&self) -> roaring::RoaringBitmap {
-        RoaringBitmap::new()
-    }
-
-    fn exploration_candidate_rules(&self) -> roaring::RoaringBitmap {
-        RoaringBitmap::new()
-    }
-
     fn derive_relational_prop(
         &self,
         _rel_expr: &crate::optimizer::RelExpr,
diff --git a/src/query/sql/src/planner/plans/eval_scalar.rs b/src/query/sql/src/planner/plans/eval_scalar.rs
index 869cd5414fcec..299495856f7fd 100644
--- a/src/query/sql/src/planner/plans/eval_scalar.rs
+++ b/src/query/sql/src/planner/plans/eval_scalar.rs
@@ -16,14 +16,12 @@ use std::sync::Arc;
 
 use common_catalog::table_context::TableContext;
 use common_exception::Result;
-use roaring::RoaringBitmap;
 
 use crate::optimizer::ColumnSet;
 use crate::optimizer::PhysicalProperty;
 use crate::optimizer::RelExpr;
 use crate::optimizer::RelationalProperty;
 use crate::optimizer::RequiredProperty;
-use crate::optimizer::RuleID;
 use crate::optimizer::Statistics;
 use crate::plans::Operator;
 use crate::plans::RelOp;
@@ -58,13 +56,6 @@ impl Operator for EvalScalar {
         RelOp::EvalScalar
     }
 
-    fn transformation_candidate_rules(&self) -> roaring::RoaringBitmap {
-        let mut ret = RoaringBitmap::new();
-        ret.push(RuleID::EliminateEvalScalar as u32);
-        ret.push(RuleID::MergeEvalScalar as u32);
-        ret
-    }
-
     fn derive_physical_prop(&self, rel_expr: &RelExpr) -> Result<PhysicalProperty> {
         rel_expr.derive_physical_prop_child(0)
     }
diff --git a/src/query/sql/src/planner/plans/filter.rs b/src/query/sql/src/planner/plans/filter.rs
index 7e05bdbc9fee5..eb5cfce14f6a4 100644
--- a/src/query/sql/src/planner/plans/filter.rs
+++ b/src/query/sql/src/planner/plans/filter.rs
@@ -17,14 +17,12 @@ use std::sync::Arc;
 
 use common_catalog::table_context::TableContext;
 use common_exception::Result;
-use roaring::RoaringBitmap;
 
 use crate::optimizer::ColumnSet;
 use crate::optimizer::PhysicalProperty;
 use crate::optimizer::RelExpr;
 use crate::optimizer::RelationalProperty;
 use crate::optimizer::RequiredProperty;
-use crate::optimizer::RuleID;
 use crate::optimizer::SelectivityEstimator;
 use crate::optimizer::Statistics;
 use crate::optimizer::MAX_SELECTIVITY;
@@ -54,15 +52,6 @@ impl Operator for Filter {
         RelOp::Filter
     }
 
-    fn transformation_candidate_rules(&self) -> roaring::RoaringBitmap {
-        let mut ret = (RuleID::NormalizeScalarFilter as u32
-            ..(RuleID::PushDownFilterSort as u32) + 1)
-            .collect::<RoaringBitmap>();
-        ret.push(RuleID::EliminateFilter as u32);
-        ret.push(RuleID::MergeFilter as u32);
-        ret
-    }
-
     fn derive_physical_prop(&self, rel_expr: &RelExpr) -> Result<PhysicalProperty> {
         rel_expr.derive_physical_prop_child(0)
     }
diff --git a/src/query/sql/src/planner/plans/limit.rs b/src/query/sql/src/planner/plans/limit.rs
index 7f31a6ac75270..3d09d0fdac707 100644
--- a/src/query/sql/src/planner/plans/limit.rs
+++ b/src/query/sql/src/planner/plans/limit.rs
@@ -16,14 +16,12 @@ use std::sync::Arc;
 
 use common_catalog::table_context::TableContext;
 use common_exception::Result;
-use roaring::RoaringBitmap;
 
 use crate::optimizer::Distribution;
 use crate::optimizer::PhysicalProperty;
 use crate::optimizer::RelExpr;
 use crate::optimizer::RelationalProperty;
 use crate::optimizer::RequiredProperty;
-use crate::optimizer::RuleID;
 use crate::optimizer::Statistics;
 use crate::plans::Operator;
 use crate::plans::RelOp;
@@ -39,11 +37,6 @@ impl Operator for Limit {
         RelOp::Limit
     }
 
-    fn transformation_candidate_rules(&self) -> roaring::RoaringBitmap {
-        (RuleID::PushDownLimitUnion as u32..(RuleID::PushDownLimitScan as u32) + 1)
-            .collect::<RoaringBitmap>()
-    }
-
     fn derive_physical_prop(&self, rel_expr: &RelExpr) -> Result<PhysicalProperty> {
         rel_expr.derive_physical_prop_child(0)
     }
diff --git a/src/query/sql/src/planner/plans/operator.rs b/src/query/sql/src/planner/plans/operator.rs
index e16be91fb7f16..32d3458a205ae 100644
--- a/src/query/sql/src/planner/plans/operator.rs
+++ b/src/query/sql/src/planner/plans/operator.rs
@@ -17,7 +17,6 @@ use std::sync::Arc;
 use common_catalog::table_context::TableContext;
 use common_exception::ErrorCode;
 use common_exception::Result;
-use roaring::RoaringBitmap;
 
 use super::aggregate::Aggregate;
 use super::dummy_table_scan::DummyTableScan;
@@ -33,7 +32,6 @@ use crate::optimizer::PhysicalProperty;
 use crate::optimizer::RelExpr;
 use crate::optimizer::RelationalProperty;
 use crate::optimizer::RequiredProperty;
-use crate::optimizer::RuleID;
 use crate::plans::runtime_filter_source::RuntimeFilterSource;
 use crate::plans::Exchange;
 
@@ -44,16 +42,6 @@ pub trait Operator {
         false
     }
 
-    fn transformation_candidate_rules(&self) -> roaring::RoaringBitmap {
-        (RuleID::NormalizeScalarFilter as u32..RuleID::CommuteJoin as u32)
-            .collect::<RoaringBitmap>()
-    }
-
-    fn exploration_candidate_rules(&self) -> roaring::RoaringBitmap {
-        (RuleID::CommuteJoin as u32..(RuleID::RightExchangeJoin as u32) + 1)
-            .collect::<RoaringBitmap>()
-    }
-
     fn derive_relational_prop(&self, rel_expr: &RelExpr) -> Result<RelationalProperty>;
 
     fn derive_physical_prop(&self, rel_expr: &RelExpr) -> Result<PhysicalProperty>;
diff --git a/src/query/sql/src/planner/plans/scan.rs b/src/query/sql/src/planner/plans/scan.rs
index afd5ee1a8cfd4..7fde68edffd36 100644
--- a/src/query/sql/src/planner/plans/scan.rs
+++ b/src/query/sql/src/planner/plans/scan.rs
@@ -20,7 +20,6 @@ use common_catalog::table::TableStatistics;
 use common_catalog::table_context::TableContext;
 use common_exception::Result;
 use itertools::Itertools;
-use roaring::RoaringBitmap;
 
 use crate::optimizer::histogram_from_ndv;
 use crate::optimizer::ColumnSet;
@@ -122,14 +121,6 @@ impl Operator for Scan {
         RelOp::Scan
     }
 
-    fn transformation_candidate_rules(&self) -> roaring::RoaringBitmap {
-        RoaringBitmap::new()
-    }
-
-    fn exploration_candidate_rules(&self) -> roaring::RoaringBitmap {
-        RoaringBitmap::new()
-    }
-
     fn derive_relational_prop(&self, _rel_expr: &RelExpr) -> Result<RelationalProperty> {
         let mut used_columns = ColumnSet::new();
         if let Some(preds) = &self.push_down_predicates {
diff --git a/src/query/sql/src/planner/plans/sort.rs b/src/query/sql/src/planner/plans/sort.rs
index bc0eb21d0502b..82873ecc89b48 100644
--- a/src/query/sql/src/planner/plans/sort.rs
+++ b/src/query/sql/src/planner/plans/sort.rs
@@ -16,14 +16,12 @@ use std::sync::Arc;
 
 use common_catalog::table_context::TableContext;
 use common_exception::Result;
-use roaring::RoaringBitmap;
 
 use crate::optimizer::Distribution;
 use crate::optimizer::PhysicalProperty;
 use crate::optimizer::RelExpr;
 use crate::optimizer::RelationalProperty;
 use crate::optimizer::RequiredProperty;
-use crate::optimizer::RuleID;
 use crate::plans::Operator;
 use crate::plans::RelOp;
 use crate::IndexType;
@@ -46,12 +44,6 @@ impl Operator for Sort {
         RelOp::Sort
     }
 
-    fn transformation_candidate_rules(&self) -> roaring::RoaringBitmap {
-        let mut ret = RoaringBitmap::new();
-        ret.push(RuleID::PushDownSortScan as u32);
-        ret
-    }
-
     fn derive_physical_prop(&self, rel_expr: &RelExpr) -> Result<PhysicalProperty> {
         rel_expr.derive_physical_prop_child(0)
     }