disable ConstantPropagation for asof join

Author: starocean999

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

@@ -238,6 +238,9 @@ public Plan visitLogicalJoin(LogicalJoin<? extends Plan, ? extends Plan> join, C
         // update: BE not support nested loop mark join, so mark join condition need to be an equation,
         // but constant propagation may rewrite an equal to TRUE/FALSE/NULL, so we don't rewrite mark join condition.
         join = visitChildren(this, join, context);
+        if (join.getJoinType().isAsofJoin()) {
+            return join;
+        }
 
         List<Expression> newHashJoinConjuncts = join.getHashJoinConjuncts();
         List<Expression> newOtherJoinConjuncts = join.getOtherJoinConjuncts();

fe/fe-core/src/test/java/org/apache/doris/nereids/rules/rewrite/ConstantPropagationTest.java

@@ -28,6 +28,7 @@
 import org.apache.doris.nereids.trees.expressions.Cast;
 import org.apache.doris.nereids.trees.expressions.EqualTo;
 import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.GreaterThan;
 import org.apache.doris.nereids.trees.expressions.IsNull;
 import org.apache.doris.nereids.trees.expressions.MatchAny;
 import org.apache.doris.nereids.trees.expressions.NamedExpression;
@@ -434,6 +435,33 @@ void testLogicalJoin() {
         Assertions.assertEquals(expectOtherConjuncts1, rewrittenJoin1.getOtherJoinConjuncts());
     }
 
+    @Test
+    void testAsofJoinDisableConstantPropagation() {
+        Set<Expression> conjunctions1 = ImmutableSet.of(
+                new EqualTo(studentId, new IntegerLiteral(1))
+        );
+        Set<Expression> conjunctions2 = ImmutableSet.of(
+                new EqualTo(scoreCid, new IntegerLiteral(2))
+        );
+        LogicalFilter left = new LogicalFilter<>(conjunctions1, student);
+        LogicalFilter right = new LogicalFilter<>(conjunctions2, score);
+
+        List<Expression> hashConjuncts = ImmutableList.of(
+                new EqualTo(studentId, scoreSid)
+        );
+        List<Expression> otherConjuncts = ImmutableList.of(
+                new GreaterThan(studentId, studentAge)
+        );
+
+        LogicalJoin asofJoin = new LogicalJoin<>(JoinType.ASOF_LEFT_INNER_JOIN, hashConjuncts, otherConjuncts, left, right, null);
+        LogicalJoin rewrittenAsofJoin = (LogicalJoin) executor.rewriteRoot(asofJoin, jobContext);
+
+        // For ASOF join, constant propagation should be disabled and no rewrite should happen.
+        Assertions.assertEquals(JoinType.ASOF_LEFT_INNER_JOIN, rewrittenAsofJoin.getJoinType());
+        Assertions.assertEquals(hashConjuncts, rewrittenAsofJoin.getHashJoinConjuncts());
+        Assertions.assertEquals(otherConjuncts, rewrittenAsofJoin.getOtherJoinConjuncts());
+    }
+
     private void assertRewrite(String expression, String expected) {
         assertRewrite(expression, expected, true);
     }