refactor(query): add the matcher id when calling the optimizer apply (#19017)

Author: zhang2014

src/query/sql/src/planner/optimizer/ir/expr/m_expr.rs

@@ -85,10 +85,10 @@ impl MExpr {
         }
 
         let mut extractor = PatternExtractor::new();
-        for pattern in rule.matchers() {
+        for (idx, pattern) in rule.matchers().iter().enumerate() {
             let exprs = extractor.extract(memo, self, pattern)?;
             for expr in exprs.iter() {
-                rule.apply(expr, transform_state)?;
+                rule.apply_matcher(idx, expr, transform_state)?;
             }
             if !exprs.is_empty() {
                 break;

src/query/sql/src/planner/optimizer/optimizers/hyper_dp/dphyp.rs

@@ -1121,20 +1121,19 @@ impl DPhpyOptimizer {
         let rule = RuleFactory::create_rule(RuleID::PushDownFilterJoin, self.opt_ctx.clone())?;
         let mut state = TransformResult::new();
 
-        if rule
-            .matchers()
-            .iter()
-            .any(|matcher| matcher.matches(&s_expr))
-            && !s_expr.applied_rule(&rule.id())
-        {
-            s_expr.set_applied_rule(&rule.id());
-            rule.apply(&s_expr, &mut state)?;
-
-            if !state.results().is_empty() {
-                // Recursive optimize the result
-                let result = &state.results()[0];
-                let optimized_result = self.push_down_filter(result)?;
-                return Ok(optimized_result);
+        for (idx, matcher) in rule.matchers().iter().enumerate() {
+            if matcher.matches(&s_expr) && !s_expr.applied_rule(&rule.id()) {
+                s_expr.set_applied_rule(&rule.id());
+                rule.apply_matcher(idx, &s_expr, &mut state)?;
+
+                if !state.results().is_empty() {
+                    // Recursive optimize the result
+                    let result = &state.results()[0];
+                    let optimized_result = self.push_down_filter(result)?;
+                    return Ok(optimized_result);
+                }
+
+                break;
             }
         }
 

src/query/sql/src/planner/optimizer/optimizers/recursive/recursive.rs

@@ -128,24 +128,24 @@ impl RecursiveRuleOptimizer {
 
             // Core optimization logic - exactly as original
             let mut state = TransformResult::new();
-            if rule
-                .matchers()
-                .iter()
-                .any(|matcher| matcher.matches(&s_expr))
-                && !s_expr.applied_rule(&rule.id())
-            {
-                s_expr.set_applied_rule(&rule.id());
-                rule.apply(&s_expr, &mut state)?;
-                if let Some(result) = state.results().first() {
-                    let result = result.clone();
-
-                    // For tracing only
-                    if trace_enabled {
-                        let duration = start_time.elapsed();
-                        self.trace_rule_execution(rule.name(), duration, &before_expr, &state)?;
+
+            for (idx, matcher) in rule.matchers().iter().enumerate() {
+                if matcher.matches(&s_expr) && !s_expr.applied_rule(&rule.id()) {
+                    s_expr.set_applied_rule(&rule.id());
+                    rule.apply_matcher(idx, &s_expr, &mut state)?;
+                    if let Some(result) = state.results().first() {
+                        let result = result.clone();
+
+                        // For tracing only
+                        if trace_enabled {
+                            let duration = start_time.elapsed();
+                            self.trace_rule_execution(rule.name(), duration, &before_expr, &state)?;
+                        }
+
+                        return Ok(Some(result));
                     }
 
-                    return Ok(Some(result));
+                    break;
                 }
             }
 

src/query/sql/src/planner/optimizer/optimizers/rule/rule.rs

@@ -76,6 +76,10 @@ pub trait Rule {
         self.id().to_string()
     }
 
+    fn apply_matcher(&self, _: usize, s_expr: &SExpr, state: &mut TransformResult) -> Result<()> {
+        self.apply(s_expr, state)
+    }
+
     fn apply(&self, s_expr: &SExpr, state: &mut TransformResult) -> Result<()>;
 
     fn matchers(&self) -> &[Matcher];