[chore](Nereids) remove some useless code (#50953)

Author: morrySnow

fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundFunction.java

@@ -46,7 +46,7 @@ public class UnboundFunction extends Function implements Unbound, PropagateNulla
     /**
      * FunctionIndexInSql
      */
-    public static class FunctionIndexInSql implements Comparable<FunctionIndexInSql> {
+    public static class FunctionIndexInSql {
         public final int functionNameBegin;
         public final int functionNameEnd;
         public final int functionExpressionEnd;
@@ -57,11 +57,6 @@ public FunctionIndexInSql(int nameBegin, int nameEnd, int expressionEnd) {
             this.functionExpressionEnd = expressionEnd;
         }
 
-        @Override
-        public int compareTo(FunctionIndexInSql functionIndexInSql) {
-            return this.functionNameBegin - functionIndexInSql.functionNameBegin;
-        }
-
         public FunctionIndexInSql indexInQueryPart(int offset) {
             return new FunctionIndexInSql(functionNameBegin - offset, functionNameEnd - offset,
                     functionExpressionEnd - offset);

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

@@ -57,7 +57,6 @@
 import org.apache.doris.nereids.trees.expressions.functions.agg.AnyValue;
 import org.apache.doris.nereids.trees.expressions.functions.generator.TableGeneratingFunction;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.GroupingScalarFunction;
-import org.apache.doris.nereids.trees.expressions.functions.scalar.Lambda;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.StructElement;
 import org.apache.doris.nereids.trees.expressions.functions.table.TableValuedFunction;
 import org.apache.doris.nereids.trees.expressions.literal.IntegerLikeLiteral;
@@ -114,7 +113,6 @@
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.lang3.StringUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
@@ -267,8 +265,7 @@ private LogicalPlan bindGenerate(MatchingContext<LogicalGenerate<Plan>> ctx) {
         Builder<Slot> outputSlots = ImmutableList.builder();
         Builder<Function> boundGenerators = ImmutableList.builder();
         List<Alias> expandAlias = Lists.newArrayList();
-        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(
-                generate, cascadesContext, generate.children(), true, true);
+        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(generate, cascadesContext, generate.children());
         for (int i = 0; i < generate.getGeneratorOutput().size(); i++) {
             UnboundSlot slot = (UnboundSlot) generate.getGeneratorOutput().get(i);
             Preconditions.checkState(slot.getNameParts().size() == 2,
@@ -338,7 +335,7 @@ private LogicalSetOperation bindSetOperation(LogicalSetOperation setOperation) {
         Builder<Plan> newChildren = ImmutableList.builderWithExpectedSize(childrenProjectionSize);
         for (int i = 0; i < childrenProjectionSize; i++) {
             Plan newChild;
-            if (childrenProjections.stream().allMatch(SlotReference.class::isInstance)) {
+            if (childrenProjections.get(i).stream().allMatch(SlotReference.class::isInstance)) {
                 newChild = setOperation.child(i);
             } else {
                 newChild = new LogicalProject<>(childrenProjections.get(i), setOperation.child(i));
@@ -355,8 +352,7 @@ private LogicalSetOperation bindSetOperation(LogicalSetOperation setOperation) {
     private LogicalOneRowRelation bindOneRowRelation(MatchingContext<UnboundOneRowRelation> ctx) {
         UnboundOneRowRelation oneRowRelation = ctx.root;
         CascadesContext cascadesContext = ctx.cascadesContext;
-        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(
-                oneRowRelation, cascadesContext, ImmutableList.of(), true, true);
+        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(oneRowRelation, cascadesContext, ImmutableList.of());
         List<NamedExpression> projects = analyzer.analyzeToList(oneRowRelation.getProjects());
         return new LogicalOneRowRelation(oneRowRelation.getRelationId(), projects);
     }
@@ -555,8 +551,7 @@ private LogicalSort<LogicalSetOperation> bindSortWithSetOperation(
         CascadesContext cascadesContext = ctx.cascadesContext;
 
         List<Slot> childOutput = sort.child().getOutput();
-        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(
-                sort, cascadesContext, sort.children(), true, true);
+        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(sort, cascadesContext, sort.children());
         Builder<OrderKey> boundKeys = ImmutableList.builderWithExpectedSize(sort.getOrderKeys().size());
         for (OrderKey orderKey : sort.getOrderKeys()) {
             Expression boundKey = bindWithOrdinal(orderKey.getExpr(), analyzer, childOutput);
@@ -571,8 +566,7 @@ private LogicalJoin<Plan, Plan> bindJoin(MatchingContext<LogicalJoin<Plan, Plan>
 
         checkConflictAlias(join);
 
-        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(
-                join, cascadesContext, join.children(), true, true);
+        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(join, cascadesContext, join.children());
 
         Builder<Expression> hashJoinConjuncts = ImmutableList.builderWithExpectedSize(
                 join.getHashJoinConjuncts().size());
@@ -670,9 +664,7 @@ private Plan bindProject(MatchingContext<LogicalProject<Plan>> ctx) {
         LogicalProject<Plan> project = ctx.root;
         CascadesContext cascadesContext = ctx.cascadesContext;
 
-        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(
-                project, cascadesContext, project.children(), true, true);
-
+        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(project, cascadesContext, project.children());
         Builder<NamedExpression> boundProjectionsBuilder
                 = ImmutableList.builderWithExpectedSize(project.getProjects().size());
         StatementContext statementContext = ctx.statementContext;
@@ -756,9 +748,7 @@ private Plan bindLoadProject(MatchingContext<LogicalLoadProject<Plan>> ctx) {
         LogicalLoadProject<Plan> project = ctx.root;
         CascadesContext cascadesContext = ctx.cascadesContext;
 
-        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(
-                project, cascadesContext, project.children(), true, true);
-
+        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(project, cascadesContext, project.children());
         Builder<NamedExpression> boundProjections = ImmutableList.builderWithExpectedSize(project.getProjects().size());
         StatementContext statementContext = ctx.statementContext;
         for (Expression expression : project.getProjects()) {
@@ -824,8 +814,7 @@ private Plan bindFilter(MatchingContext<LogicalFilter<Plan>> ctx) {
         LogicalFilter<Plan> filter = ctx.root;
         CascadesContext cascadesContext = ctx.cascadesContext;
 
-        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(
-                filter, cascadesContext, filter.children(), true, true);
+        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(filter, cascadesContext, filter.children());
         ImmutableSet.Builder<Expression> boundConjuncts = ImmutableSet.builderWithExpectedSize(
                 filter.getConjuncts().size());
         for (Expression conjunct : filter.getConjuncts()) {
@@ -840,8 +829,7 @@ private Plan bindPreFilter(MatchingContext<LogicalPreFilter<Plan>> ctx) {
         LogicalPreFilter<Plan> filter = ctx.root;
         CascadesContext cascadesContext = ctx.cascadesContext;
 
-        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(
-                filter, cascadesContext, filter.children(), true, true);
+        SimpleExprAnalyzer analyzer = buildSimpleExprAnalyzer(filter, cascadesContext, filter.children());
         ImmutableSet.Builder<Expression> boundConjuncts = ImmutableSet.builderWithExpectedSize(
                 filter.getConjuncts().size());
         for (Expression conjunct : filter.getConjuncts()) {
@@ -1052,8 +1040,7 @@ private Plan bindAggregate(MatchingContext<LogicalAggregate<Plan>> ctx) {
         LogicalAggregate<Plan> agg = ctx.root;
         CascadesContext cascadesContext = ctx.cascadesContext;
 
-        SimpleExprAnalyzer aggOutputAnalyzer = buildSimpleExprAnalyzer(
-                agg, cascadesContext, agg.children(), true, true);
+        SimpleExprAnalyzer aggOutputAnalyzer = buildSimpleExprAnalyzer(agg, cascadesContext, agg.children());
         List<NamedExpression> boundAggOutput = aggOutputAnalyzer.analyzeToList(agg.getOutputExpressions());
         List<NamedExpression> boundProjections = new ArrayList<>(boundAggOutput.size());
         for (int i = 0; i < boundAggOutput.size(); i++) {
@@ -1090,8 +1077,7 @@ private Plan bindRepeat(MatchingContext<LogicalRepeat<Plan>> ctx) {
         LogicalRepeat<Plan> repeat = ctx.root;
         CascadesContext cascadesContext = ctx.cascadesContext;
 
-        SimpleExprAnalyzer repeatOutputAnalyzer = buildSimpleExprAnalyzer(
-                repeat, cascadesContext, repeat.children(), true, true);
+        SimpleExprAnalyzer repeatOutputAnalyzer = buildSimpleExprAnalyzer(repeat, cascadesContext, repeat.children());
         List<NamedExpression> boundRepeatOutput = repeatOutputAnalyzer.analyzeToList(repeat.getOutputExpressions());
         Supplier<Scope> aggOutputScopeWithoutAggFun =
                 buildAggOutputScopeWithoutAggFun(boundRepeatOutput, cascadesContext);
@@ -1395,25 +1381,6 @@ private Expression bindWithOrdinal(
         }
     }
 
-    private <E extends Expression> E checkBoundExceptLambda(E expression, Plan plan) {
-        if (expression instanceof Lambda) {
-            return expression;
-        }
-        if (expression instanceof UnboundSlot) {
-            UnboundSlot unboundSlot = (UnboundSlot) expression;
-            String tableName = StringUtils.join(unboundSlot.getQualifier(), ".");
-            if (tableName.isEmpty()) {
-                tableName = "table list";
-            }
-            throw new AnalysisException("Unknown column '"
-                    + unboundSlot.getNameParts().get(unboundSlot.getNameParts().size() - 1)
-                    + "' in '" + tableName + "' in "
-                    + plan.getType().toString().substring("LOGICAL_".length()) + " clause");
-        }
-        expression.children().forEach(e -> checkBoundExceptLambda(e, plan));
-        return expression;
-    }
-
     private Scope toScope(CascadesContext cascadesContext, List<Slot> slots) {
         Optional<Scope> outerScope = cascadesContext.getOuterScope();
         if (outerScope.isPresent()) {
@@ -1433,19 +1400,12 @@ private Scope toScope(CascadesContext cascadesContext, List<Slot> slots, List<Sl
     }
 
     private SimpleExprAnalyzer buildSimpleExprAnalyzer(
-            Plan currentPlan, CascadesContext cascadesContext, List<Plan> children,
-            boolean enableExactMatch, boolean bindSlotInOuterScope) {
+            Plan currentPlan, CascadesContext cascadesContext, List<Plan> children) {
         Scope scope = toScope(cascadesContext, PlanUtils.fastGetChildrenOutputs(children),
                 PlanUtils.fastGetChildrenAsteriskOutputs(children));
-        return buildSimpleExprAnalyzer(currentPlan, cascadesContext, scope, enableExactMatch, bindSlotInOuterScope);
-    }
-
-    private SimpleExprAnalyzer buildSimpleExprAnalyzer(
-            Plan currentPlan, CascadesContext cascadesContext, Scope scope,
-            boolean enableExactMatch, boolean bindSlotInOuterScope) {
         ExpressionRewriteContext rewriteContext = new ExpressionRewriteContext(cascadesContext);
         ExpressionAnalyzer expressionAnalyzer = new ExpressionAnalyzer(currentPlan,
-                scope, cascadesContext, enableExactMatch, bindSlotInOuterScope);
+                scope, cascadesContext, true, true);
         return expr -> expressionAnalyzer.analyze(expr, rewriteContext);
     }
 

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

@@ -112,8 +112,6 @@ private void extractLeading(SelectHintLeading selectHint, CascadesContext contex
         } else {
             context.setLeadingJoin(true);
         }
-        assert (selectHint != null);
-        assert (context != null);
     }
 
     private void extractRule(SelectHintUseCboRule selectHint, StatementContext statementContext) {

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

@@ -56,7 +56,6 @@
 import org.apache.doris.nereids.trees.expressions.InSubquery;
 import org.apache.doris.nereids.trees.expressions.IntegralDivide;
 import org.apache.doris.nereids.trees.expressions.Match;
-import org.apache.doris.nereids.trees.expressions.NamedExpression;
 import org.apache.doris.nereids.trees.expressions.Not;
 import org.apache.doris.nereids.trees.expressions.Or;
 import org.apache.doris.nereids.trees.expressions.Placeholder;
@@ -67,7 +66,6 @@
 import org.apache.doris.nereids.trees.expressions.WhenClause;
 import org.apache.doris.nereids.trees.expressions.functions.BoundFunction;
 import org.apache.doris.nereids.trees.expressions.functions.FunctionBuilder;
-import org.apache.doris.nereids.trees.expressions.functions.scalar.ElementAt;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.Lambda;
 import org.apache.doris.nereids.trees.expressions.functions.udf.AliasUdfBuilder;
 import org.apache.doris.nereids.trees.expressions.functions.udf.JavaUdaf;
@@ -266,10 +264,6 @@ public Expression visitUnboundAlias(UnboundAlias unboundAlias, ExpressionRewrite
         Expression child = unboundAlias.child().accept(this, context);
         if (unboundAlias.getAlias().isPresent()) {
             return new Alias(child, unboundAlias.getAlias().get(), unboundAlias.isNameFromChild());
-            // TODO: the variant bind element_at(slot, 'name') will return a slot, and we should
-            //       assign an Alias to this function, this is trick and should refactor it
-        } else if (!(unboundAlias.child() instanceof ElementAt) && child instanceof NamedExpression) {
-            return new Alias(child, ((NamedExpression) child).getName());
         } else {
             return new Alias(child);
         }
@@ -891,10 +885,6 @@ public List<Slot> bindSlotByScope(UnboundSlot unboundSlot, Scope scope) {
         }
     }
 
-    public static boolean compareDbName(String boundedDbName, String unBoundDbName) {
-        return unBoundDbName.equalsIgnoreCase(boundedDbName);
-    }
-
     public static boolean sameTableName(String boundSlot, String unboundSlot) {
         if (GlobalVariable.lowerCaseTableNames != 1) {
             return boundSlot.equals(unboundSlot);

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

@@ -26,7 +26,6 @@
 import org.apache.doris.nereids.rules.expression.ExpressionRewriteContext;
 import org.apache.doris.nereids.rules.expression.rules.TrySimplifyPredicateWithMarkJoinSlot;
 import org.apache.doris.nereids.trees.expressions.Alias;
-import org.apache.doris.nereids.trees.expressions.And;
 import org.apache.doris.nereids.trees.expressions.CompoundPredicate;
 import org.apache.doris.nereids.trees.expressions.Exists;
 import org.apache.doris.nereids.trees.expressions.Expression;
@@ -35,7 +34,6 @@
 import org.apache.doris.nereids.trees.expressions.LessThanEqual;
 import org.apache.doris.nereids.trees.expressions.MarkJoinSlotReference;
 import org.apache.doris.nereids.trees.expressions.NamedExpression;
-import org.apache.doris.nereids.trees.expressions.Not;
 import org.apache.doris.nereids.trees.expressions.Or;
 import org.apache.doris.nereids.trees.expressions.ScalarSubquery;
 import org.apache.doris.nereids.trees.expressions.Slot;
@@ -677,24 +675,6 @@ private enum SearchState {
         SearchExistsOrInSubquery
     }
 
-    private boolean shouldOutputMarkJoinSlot(Expression expr, SearchState searchState) {
-        if (searchState == SearchState.SearchNot && expr instanceof Not) {
-            if (shouldOutputMarkJoinSlot(((Not) expr).child(), SearchState.SearchAnd)) {
-                return true;
-            }
-        } else if (searchState == SearchState.SearchAnd && expr instanceof And) {
-            for (Expression child : expr.children()) {
-                if (shouldOutputMarkJoinSlot(child, SearchState.SearchExistsOrInSubquery)) {
-                    return true;
-                }
-            }
-        } else if (searchState == SearchState.SearchExistsOrInSubquery
-                && (expr instanceof InSubquery || expr instanceof Exists)) {
-            return true;
-        }
-        return false;
-    }
-
     private List<Boolean> shouldOutputMarkJoinSlot(Collection<Expression> conjuncts) {
         ImmutableList.Builder<Boolean> result = ImmutableList.builderWithExpectedSize(conjuncts.size());
         for (Expression expr : conjuncts) {