[opt](Nereids) remove between expression to simplify planner

fe/fe-core/src/main/java/org/apache/doris/nereids/glue/translator/ExpressionTranslator.java

@@ -49,7 +49,6 @@
 import org.apache.doris.nereids.trees.expressions.Alias;
 import org.apache.doris.nereids.trees.expressions.And;
 import org.apache.doris.nereids.trees.expressions.AssertNumRowsElement;
-import org.apache.doris.nereids.trees.expressions.Between;
 import org.apache.doris.nereids.trees.expressions.BinaryArithmetic;
 import org.apache.doris.nereids.trees.expressions.CaseWhen;
 import org.apache.doris.nereids.trees.expressions.Cast;
@@ -281,11 +280,6 @@ public Expr visitNullLiteral(NullLiteral nullLiteral, PlanTranslatorContext cont
         return nullLit;
     }
 
-    @Override
-    public Expr visitBetween(Between between, PlanTranslatorContext context) {
-        throw new RuntimeException("Unexpected invocation");
-    }
-
     @Override
     public Expr visitAnd(And and, PlanTranslatorContext context) {
         return new org.apache.doris.analysis.CompoundPredicate(

fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java

@@ -134,7 +134,6 @@
 import org.apache.doris.nereids.properties.SelectHint;
 import org.apache.doris.nereids.trees.expressions.Add;
 import org.apache.doris.nereids.trees.expressions.And;
-import org.apache.doris.nereids.trees.expressions.Between;
 import org.apache.doris.nereids.trees.expressions.BitAnd;
 import org.apache.doris.nereids.trees.expressions.BitNot;
 import org.apache.doris.nereids.trees.expressions.BitOr;
@@ -1827,10 +1826,9 @@ private Expression withPredicate(Expression valueExpression, PredicateContext ct
             Expression outExpression;
             switch (ctx.kind.getType()) {
                 case DorisParser.BETWEEN:
-                    outExpression = new Between(
-                            valueExpression,
-                            getExpression(ctx.lower),
-                            getExpression(ctx.upper)
+                    outExpression = new And(
+                            new GreaterThanEqual(valueExpression, getExpression(ctx.lower)),
+                            new LessThanEqual(valueExpression, getExpression(ctx.upper))
                     );
                     break;
                 case DorisParser.LIKE:

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

@@ -18,7 +18,6 @@
 package org.apache.doris.nereids.rules.expression;
 
 import org.apache.doris.nereids.rules.expression.check.CheckCast;
-import org.apache.doris.nereids.rules.expression.rules.BetweenToCompoundRule;
 import org.apache.doris.nereids.rules.expression.rules.DigitalMaskingConvert;
 import org.apache.doris.nereids.rules.expression.rules.FoldConstantRule;
 import org.apache.doris.nereids.rules.expression.rules.InPredicateDedup;
@@ -46,7 +45,6 @@ public class ExpressionNormalization extends ExpressionRewrite {
             SupportJavaDateFormatter.INSTANCE,
             ReplaceVariableByLiteral.INSTANCE,
             NormalizeBinaryPredicatesRule.INSTANCE,
-            BetweenToCompoundRule.INSTANCE,
             InPredicateDedup.INSTANCE,
             InPredicateToEqualToRule.INSTANCE,
             SimplifyNotExprRule.INSTANCE,

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

@@ -30,7 +30,6 @@
 import org.apache.doris.nereids.rules.expression.AbstractExpressionRewriteRule;
 import org.apache.doris.nereids.rules.expression.ExpressionRewriteContext;
 import org.apache.doris.nereids.trees.expressions.Alias;
-import org.apache.doris.nereids.trees.expressions.Between;
 import org.apache.doris.nereids.trees.expressions.Cast;
 import org.apache.doris.nereids.trees.expressions.Expression;
 import org.apache.doris.nereids.trees.expressions.literal.Literal;
@@ -126,10 +125,6 @@ private void collectConst(Expression expr, Map<String, Expression> constMap, Map
             if (expr.isLiteral()) {
                 return;
             }
-            // skip BetweenPredicate need to be rewrite to CompoundPredicate
-            if (expr instanceof Between) {
-                return;
-            }
             String id = idGenerator.getNextId().toString();
             constMap.put(id, expr);
             Expr staleExpr = ExpressionTranslator.translate(expr, null);

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

@@ -25,7 +25,6 @@
 import org.apache.doris.nereids.rules.analysis.ArithmeticFunctionBinder;
 import org.apache.doris.nereids.rules.expression.AbstractExpressionRewriteRule;
 import org.apache.doris.nereids.rules.expression.ExpressionRewriteContext;
-import org.apache.doris.nereids.trees.expressions.Between;
 import org.apache.doris.nereids.trees.expressions.BinaryArithmetic;
 import org.apache.doris.nereids.trees.expressions.BitNot;
 import org.apache.doris.nereids.trees.expressions.CaseWhen;
@@ -234,14 +233,6 @@ public Expression visitInPredicate(InPredicate inPredicate, ExpressionRewriteCon
         return TypeCoercionUtils.processInPredicate(newInPredicate);
     }
 
-    @Override
-    public Expression visitBetween(Between between, ExpressionRewriteContext context) {
-        List<Expression> rewrittenChildren = between.children().stream()
-                .map(e -> e.accept(this, context)).collect(Collectors.toList());
-        Between newBetween = between.withChildren(rewrittenChildren);
-        return TypeCoercionUtils.processBetween(newBetween);
-    }
-
     @Override
     public Expression visitInSubquery(InSubquery inSubquery, ExpressionRewriteContext context) {
         Expression newCompareExpr = inSubquery.getCompareExpr().accept(this, context);

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ExpressionVisitor.java

@@ -27,7 +27,6 @@
 import org.apache.doris.nereids.trees.expressions.Alias;
 import org.apache.doris.nereids.trees.expressions.And;
 import org.apache.doris.nereids.trees.expressions.AssertNumRowsElement;
-import org.apache.doris.nereids.trees.expressions.Between;
 import org.apache.doris.nereids.trees.expressions.BinaryArithmetic;
 import org.apache.doris.nereids.trees.expressions.BinaryOperator;
 import org.apache.doris.nereids.trees.expressions.BitAnd;
@@ -295,10 +294,6 @@ public R visitArrayLiteral(ArrayLiteral arrayLiteral, C context) {
         return visitLiteral(arrayLiteral, context);
     }
 
-    public R visitBetween(Between between, C context) {
-        return visit(between, context);
-    }
-
     public R visitCompoundPredicate(CompoundPredicate compoundPredicate, C context) {
         return visitBinaryOperator(compoundPredicate, context);
     }

fe/fe-core/src/main/java/org/apache/doris/nereids/util/TypeCoercionUtils.java

@@ -24,7 +24,6 @@
 import org.apache.doris.nereids.annotation.Developing;
 import org.apache.doris.nereids.exceptions.AnalysisException;
 import org.apache.doris.nereids.trees.expressions.Add;
-import org.apache.doris.nereids.trees.expressions.Between;
 import org.apache.doris.nereids.trees.expressions.BinaryArithmetic;
 import org.apache.doris.nereids.trees.expressions.BinaryOperator;
 import org.apache.doris.nereids.trees.expressions.BitAnd;
@@ -894,33 +893,6 @@ public static Expression processCompoundPredicate(CompoundPredicate compoundPred
         return compoundPredicate.withChildren(children);
     }
 
-    /**
-     * process between type coercion.
-     */
-    public static Expression processBetween(Between between) {
-        // check
-        between.checkLegalityBeforeTypeCoercion();
-
-        if (between.getLowerBound().getDataType().equals(between.getCompareExpr().getDataType())
-                && between.getUpperBound().getDataType().equals(between.getCompareExpr().getDataType())) {
-            return between;
-        }
-        Optional<DataType> optionalCommonType = TypeCoercionUtils.findWiderCommonTypeForComparison(
-                between.children()
-                        .stream()
-                        .map(Expression::getDataType)
-                        .collect(Collectors.toList()));
-
-        return optionalCommonType
-                .map(commonType -> {
-                    List<Expression> newChildren = between.children().stream()
-                            .map(e -> TypeCoercionUtils.castIfNotMatchType(e, commonType))
-                            .collect(Collectors.toList());
-                    return between.withChildren(newChildren);
-                })
-                .orElse(between);
-    }
-
     private static boolean canCompareDate(DataType t1, DataType t2) {
         DataType dateType = t1;
         DataType anotherType = t2;

fe/fe-core/src/test/java/org/apache/doris/nereids/rules/expression/ExpressionRewriteTest.java

@@ -17,7 +17,6 @@
 
 package org.apache.doris.nereids.rules.expression;
 
-import org.apache.doris.nereids.rules.expression.rules.BetweenToCompoundRule;
 import org.apache.doris.nereids.rules.expression.rules.DistinctPredicatesRule;
 import org.apache.doris.nereids.rules.expression.rules.ExtractCommonFactorRule;
 import org.apache.doris.nereids.rules.expression.rules.InPredicateDedup;
@@ -164,16 +163,6 @@ public void testExtractCommonFactorRewrite() {
 
     }
 
-    @Test
-    public void testBetweenToCompoundRule() {
-        executor = new ExpressionRuleExecutor(ImmutableList.of(BetweenToCompoundRule.INSTANCE,
-                SimplifyNotExprRule.INSTANCE));
-
-        assertRewrite("a between c and d", "(a >= c) and (a <= d)");
-        assertRewrite("a not between c and d)", "(a < c) or (a > d)");
-
-    }
-
     @Test
     public void testInPredicateToEqualToRule() {
         executor = new ExpressionRuleExecutor(ImmutableList.of(InPredicateToEqualToRule.INSTANCE));

fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/ExpressionEqualsTest.java

@@ -83,14 +83,6 @@ public void testComparisonPredicate() {
         Assertions.assertEquals(greaterThanEqual1.hashCode(), greaterThanEqual2.hashCode());
     }
 
-    @Test
-    public void testBetween() {
-        Between between1 = new Between(child1, left1, right1);
-        Between between2 = new Between(child2, left2, right2);
-        Assertions.assertEquals(between1, between2);
-        Assertions.assertEquals(between1.hashCode(), between2.hashCode());
-    }
-
     @Test
     public void testNot() {
         Not not1 = new Not(child1);

fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/ExpressionParserTest.java

@@ -60,10 +60,9 @@ public void testSqlBetweenPredicate() {
     public void testExprBetweenPredicate() {
         parseExpression("c BETWEEN a AND b")
                 .assertEquals(
-                        new Between(
-                                new UnboundSlot("c"),
-                                new UnboundSlot("a"),
-                                new UnboundSlot("b")
+                        new And(
+                                new GreaterThanEqual(new UnboundSlot("c"), new UnboundSlot("a")),
+                                new LessThanEqual(new UnboundSlot("c"), new UnboundSlot("b"))
                         )
                 );
     }