query rewrite support filter valid partition filter

fe/fe-core/src/main/java/org/apache/doris/catalog/MTMV.java

@@ -35,6 +35,7 @@
 import org.apache.doris.mtmv.MTMVRelation;
 import org.apache.doris.mtmv.MTMVStatus;
 import org.apache.doris.persist.gson.GsonUtils;
+import org.apache.doris.qe.ConnectContext;
 
 import com.google.common.collect.Sets;
 import com.google.gson.annotations.SerializedName;
@@ -189,12 +190,13 @@ public Set<String> getExcludedTriggerTables() {
         return Sets.newHashSet(split);
     }
 
-    public MTMVCache getOrGenerateCache() throws AnalysisException {
+    // this should use the same connectContext with query, to use the same session variable
+    public MTMVCache getOrGenerateCache(ConnectContext parent) throws AnalysisException {
         if (cache == null) {
             writeMvLock();
             try {
                 if (cache == null) {
-                    this.cache = MTMVCache.from(this, MTMVPlanUtil.createMTMVContext(this));
+                    this.cache = MTMVCache.from(this, parent);
                 }
             } finally {
                 writeMvUnlock();

fe/fe-core/src/main/java/org/apache/doris/mtmv/MTMVRelationManager.java

@@ -51,7 +51,7 @@ public class MTMVRelationManager implements MTMVHookService {
 
     public Set<BaseTableInfo> getMtmvsByBaseTable(BaseTableInfo table) {
         Set<BaseTableInfo> baseTableInfos = tableMTMVs.get(table);
-        return baseTableInfos == null? ImmutableSet.of() : baseTableInfos;
+        return baseTableInfos == null ? ImmutableSet.of() : baseTableInfos;
     }
 
     public Set<MTMV> getAvailableMTMVs(List<BaseTableInfo> tableInfos) {

fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleSet.java

@@ -41,7 +41,11 @@
 import org.apache.doris.nereids.rules.exploration.join.SemiJoinSemiJoinTranspose;
 import org.apache.doris.nereids.rules.exploration.join.SemiJoinSemiJoinTransposeProject;
 import org.apache.doris.nereids.rules.exploration.mv.MaterializedViewAggregateRule;
+import org.apache.doris.nereids.rules.exploration.mv.MaterializedViewFilterJoinRule;
+import org.apache.doris.nereids.rules.exploration.mv.MaterializedViewFilterProjectJoinRule;
+import org.apache.doris.nereids.rules.exploration.mv.MaterializedViewOnlyJoinRule;
 import org.apache.doris.nereids.rules.exploration.mv.MaterializedViewProjectAggregateRule;
+import org.apache.doris.nereids.rules.exploration.mv.MaterializedViewProjectFilterJoinRule;
 import org.apache.doris.nereids.rules.exploration.mv.MaterializedViewProjectJoinRule;
 import org.apache.doris.nereids.rules.implementation.AggregateStrategies;
 import org.apache.doris.nereids.rules.implementation.LogicalAssertNumRowsToPhysicalAssertNumRows;
@@ -224,7 +228,11 @@ public class RuleSet {
             .build();
 
     public static final List<Rule> MATERIALIZED_VIEW_RULES = planRuleFactories()
+            .add(MaterializedViewOnlyJoinRule.INSTANCE)
             .add(MaterializedViewProjectJoinRule.INSTANCE)
+            .add(MaterializedViewFilterJoinRule.INSTANCE)
+            .add(MaterializedViewFilterProjectJoinRule.INSTANCE)
+            .add(MaterializedViewProjectFilterJoinRule.INSTANCE)
             .add(MaterializedViewAggregateRule.INSTANCE)
             .add(MaterializedViewProjectAggregateRule.INSTANCE)
             .build();

fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/mv/AbstractMaterializedViewAggregateRule.java

@@ -47,6 +47,8 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Sets;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -64,6 +66,8 @@ public abstract class AbstractMaterializedViewAggregateRule extends AbstractMate
 
     protected static final Map<PlaceholderExpression, PlaceholderExpression>
             AGGREGATE_ROLL_UP_EQUIVALENT_FUNCTION_MAP = new HashMap<>();
+    protected final String currentClassName = this.getClass().getSimpleName();
+    private final Logger logger = LogManager.getLogger(this.getClass());
 
     static {
         AGGREGATE_ROLL_UP_EQUIVALENT_FUNCTION_MAP.put(
@@ -81,10 +85,12 @@ protected Plan rewriteQueryByView(MatchMode matchMode,
         // get view and query aggregate and top plan correspondingly
         Pair<Plan, LogicalAggregate<Plan>> viewTopPlanAndAggPair = splitToTopPlanAndAggregate(viewStructInfo);
         if (viewTopPlanAndAggPair == null) {
+            logger.info(currentClassName + "split to view to top plan and agg fail so return null");
             return null;
         }
         Pair<Plan, LogicalAggregate<Plan>> queryTopPlanAndAggPair = splitToTopPlanAndAggregate(queryStructInfo);
         if (queryTopPlanAndAggPair == null) {
+            logger.info(currentClassName + "split to query to top plan and agg fail so return null");
             return null;
         }
         // Firstly, handle query group by expression rewrite
@@ -113,6 +119,7 @@ protected Plan rewriteQueryByView(MatchMode matchMode,
                     true);
             if (rewrittenQueryGroupExpr.isEmpty()) {
                 // can not rewrite, bail out.
+                logger.info(currentClassName + " can not rewrite expression when not need roll up");
                 return null;
             }
             return new LogicalProject<>(
@@ -127,12 +134,14 @@ protected Plan rewriteQueryByView(MatchMode matchMode,
                 viewExpr -> viewExpr.anyMatch(expr -> expr instanceof AggregateFunction
                         && ((AggregateFunction) expr).isDistinct()))) {
             // if mv aggregate function contains distinct, can not roll up, bail out.
+            logger.info(currentClassName + " view contains distinct function so can not roll up");
             return null;
         }
         // split the query top plan expressions to group expressions and functions, if can not, bail out.
         Pair<Set<? extends Expression>, Set<? extends Expression>> queryGroupAndFunctionPair
                 = topPlanSplitToGroupAndFunction(queryTopPlanAndAggPair);
         if (queryGroupAndFunctionPair == null) {
+            logger.info(currentClassName + " query top plan split to group by and function fail so return null");
             return null;
         }
         // Secondly, try to roll up the agg functions
@@ -159,6 +168,8 @@ protected Plan rewriteQueryByView(MatchMode matchMode,
                 Function rollupAggregateFunction = rollup(queryFunction,
                         queryFunctionShuttled, mvExprToMvScanExprQueryBased);
                 if (rollupAggregateFunction == null) {
+                    logger.info(currentClassName + " query function " + queryFunction.getName()
+                            + " can not roll up so return null");
                     return null;
                 }
                 // key is query need roll up expr, value is mv scan based roll up expr
@@ -170,6 +181,7 @@ protected Plan rewriteQueryByView(MatchMode matchMode,
                         queryToViewSlotMapping,
                         false);
                 if (rewrittenFunctionExpression == null) {
+                    logger.info(currentClassName + " roll up expression can not rewrite by view so return null");
                     return null;
                 }
                 finalAggregateExpressions.add((NamedExpression) rewrittenFunctionExpression);
@@ -179,6 +191,8 @@ protected Plan rewriteQueryByView(MatchMode matchMode,
                         ExpressionUtils.shuttleExpressionWithLineage(topExpression, queryTopPlan);
                 if (!mvExprToMvScanExprQueryBased.containsKey(queryGroupShuttledExpr)) {
                     // group expr can not rewrite by view
+                    logger.info(currentClassName
+                            + " view group expressions can not contains the query group by expression so return null");
                     return null;
                 }
                 groupRewrittenExprMap.put(queryGroupShuttledExpr,
@@ -191,6 +205,7 @@ protected Plan rewriteQueryByView(MatchMode matchMode,
                         queryToViewSlotMapping,
                         true);
                 if (rewrittenGroupExpression == null) {
+                    logger.info(currentClassName + " query top expression can not be rewritten by view so return null");
                     return null;
                 }
                 finalAggregateExpressions.add((NamedExpression) rewrittenGroupExpression);

fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/mv/AbstractMaterializedViewJoinRule.java

@@ -27,6 +27,9 @@
 import org.apache.doris.nereids.trees.plans.Plan;
 import org.apache.doris.nereids.trees.plans.logical.LogicalProject;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -35,6 +38,10 @@
  * This is responsible for common join rewriting
  */
 public abstract class AbstractMaterializedViewJoinRule extends AbstractMaterializedViewRule {
+
+    protected final String currentClassName = this.getClass().getSimpleName();
+    private final Logger logger = LogManager.getLogger(this.getClass());
+
     @Override
     protected Plan rewriteQueryByView(MatchMode matchMode,
             StructInfo queryStructInfo,
@@ -53,6 +60,7 @@ protected Plan rewriteQueryByView(MatchMode matchMode,
         // Can not rewrite, bail out
         if (expressionsRewritten.isEmpty()
                 || expressionsRewritten.stream().anyMatch(expr -> !(expr instanceof NamedExpression))) {
+            logger.info(currentClassName + " expression to rewrite is not named expr so return null");
             return null;
         }
         // record the group id in materializationContext, and when rewrite again in