This is an automated email from the ASF dual-hosted git repository. yiguolei pushed a commit to branch branch-2.1 in repository https://gitbox.apache.org/repos/asf/doris.git
commit 22efb1cb7a00dfb358b03c5142ffb6363caa785f Author: morrySnow <[email protected]> AuthorDate: Thu Feb 22 19:03:25 2024 +0800 [fix](Nereids) not equals and hashCode should contains generate flag (#31123) --- .../mv/AbstractMaterializedViewRule.java | 12 ++++++++-- .../nereids/rules/rewrite/EliminateNotNull.java | 11 ++++++--- .../nereids/rules/rewrite/EliminateOuterJoin.java | 9 +++----- .../nereids/rules/rewrite/InferAggNotNull.java | 25 ++++++++++++++++---- .../nereids/rules/rewrite/InferFilterNotNull.java | 26 ++++++++++++++------- .../nereids/trees/expressions/Expression.java | 1 - .../doris/nereids/trees/expressions/Not.java | 27 +++++++++++++++++----- .../trees/plans/commands/DeleteFromCommand.java | 24 ++++++++++++++++--- .../apache/doris/nereids/util/ExpressionUtils.java | 14 ++++------- .../java/org/apache/doris/qe/SessionVariable.java | 2 +- .../nereids/rules/rewrite/InferAggNotNullTest.java | 4 +++- .../eliminate_not_null/eliminate_not_null.out | 16 ++++++------- 12 files changed, 118 insertions(+), 53 deletions(-) diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/mv/AbstractMaterializedViewRule.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/mv/AbstractMaterializedViewRule.java index 12f409a5946..4840416667c 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/mv/AbstractMaterializedViewRule.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/mv/AbstractMaterializedViewRule.java @@ -37,6 +37,7 @@ import org.apache.doris.nereids.rules.exploration.mv.mapping.SlotMapping; import org.apache.doris.nereids.trees.expressions.Alias; import org.apache.doris.nereids.trees.expressions.Expression; import org.apache.doris.nereids.trees.expressions.NamedExpression; +import org.apache.doris.nereids.trees.expressions.Not; import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.doris.nereids.trees.expressions.functions.scalar.NonNullable; import org.apache.doris.nereids.trees.expressions.functions.scalar.Nullable; @@ -500,9 +501,16 @@ public abstract class AbstractMaterializedViewRule implements ExplorationRuleFac CascadesContext cascadesContext) { Set<Expression> queryPulledUpPredicates = queryPredicates.stream() .flatMap(expr -> ExpressionUtils.extractConjunction(expr).stream()) + .map(expr -> { + // NOTICE inferNotNull generate Not with isGeneratedIsNotNull = false, + // so, we need set this flag to false before comparison. + if (expr instanceof Not) { + return ((Not) expr).withGeneratedIsNotNull(false); + } + return expr; + }) .collect(Collectors.toSet()); - Set<Expression> nullRejectPredicates = ExpressionUtils.inferNotNull(queryPulledUpPredicates, - cascadesContext); + Set<Expression> nullRejectPredicates = ExpressionUtils.inferNotNull(queryPulledUpPredicates, cascadesContext); Set<Expression> queryUsedNeedRejectNullSlotsViewBased = nullRejectPredicates.stream() .map(expression -> TypeUtils.isNotNull(expression).orElse(null)) .filter(Objects::nonNull) diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/EliminateNotNull.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/EliminateNotNull.java index a4d8eca40e3..5bfc8778d2a 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/EliminateNotNull.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/EliminateNotNull.java @@ -53,19 +53,23 @@ public class EliminateNotNull implements RewriteRuleFactory { public List<Rule> buildRules() { return ImmutableList.of( logicalFilter() - .when(filter -> filter.getConjuncts().stream().anyMatch(expr -> expr.isGeneratedIsNotNull)) .thenApply(ctx -> { LogicalFilter<Plan> filter = ctx.root; List<Expression> predicates = removeGeneratedNotNull(filter.getConjuncts(), ctx.cascadesContext); + if (predicates.size() == filter.getConjuncts().size()) { + return null; + } return PlanUtils.filterOrSelf(ImmutableSet.copyOf(predicates), filter.child()); }).toRule(RuleType.ELIMINATE_NOT_NULL), innerLogicalJoin() - .when(join -> join.getOtherJoinConjuncts().stream().anyMatch(expr -> expr.isGeneratedIsNotNull)) .thenApply(ctx -> { LogicalJoin<Plan, Plan> join = ctx.root; List<Expression> newOtherJoinConjuncts = removeGeneratedNotNull( join.getOtherJoinConjuncts(), ctx.cascadesContext); + if (newOtherJoinConjuncts.size() == join.getOtherJoinConjuncts().size()) { + return null; + } return join.withJoinConjuncts(join.getHashJoinConjuncts(), newOtherJoinConjuncts); }) .toRule(RuleType.ELIMINATE_NOT_NULL) @@ -81,7 +85,8 @@ public class EliminateNotNull implements RewriteRuleFactory { Set<Expression> predicatesNotContainIsNotNull = Sets.newHashSet(); List<Slot> slotsFromIsNotNull = Lists.newArrayList(); exprs.stream() - .filter(expr -> !expr.isGeneratedIsNotNull) // remove generated `is not null` + .filter(expr -> !(expr instanceof Not) + || !((Not) expr).isGeneratedIsNotNull()) // remove generated `is not null` .forEach(expr -> { Optional<Slot> notNullSlot = TypeUtils.isNotNull(expr); if (notNullSlot.isPresent()) { diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/EliminateOuterJoin.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/EliminateOuterJoin.java index 1afd6a175f3..08d916bc20a 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/EliminateOuterJoin.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/EliminateOuterJoin.java @@ -75,8 +75,7 @@ public class EliminateOuterJoin extends OneRewriteRuleFactory { boolean conjunctsChanged = false; if (!notNullSlots.isEmpty()) { for (Slot slot : notNullSlots) { - Not isNotNull = new Not(new IsNull(slot)); - isNotNull.isGeneratedIsNotNull = true; + Not isNotNull = new Not(new IsNull(slot), true); conjunctsChanged |= conjuncts.add(isNotNull); } } @@ -135,13 +134,11 @@ public class EliminateOuterJoin extends OneRewriteRuleFactory { private boolean createIsNotNullIfNecessary(EqualPredicate swapedEqualTo, Collection<Expression> container) { boolean containerChanged = false; if (swapedEqualTo.left().nullable()) { - Not not = new Not(new IsNull(swapedEqualTo.left())); - not.isGeneratedIsNotNull = true; + Not not = new Not(new IsNull(swapedEqualTo.left()), true); containerChanged |= container.add(not); } if (swapedEqualTo.right().nullable()) { - Not not = new Not(new IsNull(swapedEqualTo.right())); - not.isGeneratedIsNotNull = true; + Not not = new Not(new IsNull(swapedEqualTo.right()), true); containerChanged |= container.add(not); } return containerChanged; diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/InferAggNotNull.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/InferAggNotNull.java index 55bf93ca58c..e30190592a6 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/InferAggNotNull.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/InferAggNotNull.java @@ -20,6 +20,7 @@ package org.apache.doris.nereids.rules.rewrite; import org.apache.doris.nereids.rules.Rule; import org.apache.doris.nereids.rules.RuleType; import org.apache.doris.nereids.trees.expressions.Expression; +import org.apache.doris.nereids.trees.expressions.Not; import org.apache.doris.nereids.trees.expressions.functions.agg.AggregateFunction; import org.apache.doris.nereids.trees.expressions.functions.agg.Avg; import org.apache.doris.nereids.trees.expressions.functions.agg.Count; @@ -32,6 +33,9 @@ import org.apache.doris.nereids.trees.plans.logical.LogicalAggregate; import org.apache.doris.nereids.util.ExpressionUtils; import org.apache.doris.nereids.util.PlanUtils; +import com.google.common.collect.ImmutableSet; + +import java.util.Collections; import java.util.Set; import java.util.stream.Collectors; @@ -55,12 +59,25 @@ public class InferAggNotNull extends OneRewriteRuleFactory { LogicalAggregate<Plan> agg = ctx.root; Set<Expression> exprs = agg.getAggregateFunctions().stream().flatMap(f -> f.children().stream()) .collect(Collectors.toSet()); - Set<Expression> isNotNull = ExpressionUtils.inferNotNull(exprs, ctx.cascadesContext); - if (isNotNull.size() == 0 || (agg.child() instanceof Filter && isNotNull.equals( - ((Filter) agg.child()).getConjuncts()))) { + Set<Expression> isNotNulls = ExpressionUtils.inferNotNull(exprs, ctx.cascadesContext); + Set<Expression> predicates = Collections.emptySet(); + if ((agg.child() instanceof Filter)) { + predicates = ((Filter) agg.child()).getConjuncts(); + } + ImmutableSet.Builder<Expression> needGenerateNotNullsBuilder = ImmutableSet.builder(); + for (Expression isNotNull : isNotNulls) { + if (!predicates.contains(isNotNull)) { + isNotNull = ((Not) isNotNull).withGeneratedIsNotNull(true); + if (!predicates.contains(isNotNull)) { + needGenerateNotNullsBuilder.add(isNotNull); + } + } + } + Set<Expression> needGenerateNotNulls = needGenerateNotNullsBuilder.build(); + if (needGenerateNotNulls.isEmpty()) { return null; } - return agg.withChildren(PlanUtils.filter(isNotNull, agg.child()).get()); + return agg.withChildren(PlanUtils.filter(needGenerateNotNulls, agg.child()).get()); }).toRule(RuleType.INFER_AGG_NOT_NULL); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/InferFilterNotNull.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/InferFilterNotNull.java index e166a1ac892..f19976cb753 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/InferFilterNotNull.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/InferFilterNotNull.java @@ -20,13 +20,14 @@ package org.apache.doris.nereids.rules.rewrite; import org.apache.doris.nereids.rules.Rule; import org.apache.doris.nereids.rules.RuleType; import org.apache.doris.nereids.trees.expressions.Expression; +import org.apache.doris.nereids.trees.expressions.Not; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.logical.LogicalFilter; import org.apache.doris.nereids.util.ExpressionUtils; import org.apache.doris.nereids.util.PlanUtils; import com.google.common.collect.ImmutableSet; -import com.google.common.collect.ImmutableSet.Builder; +import com.google.common.collect.Streams; import java.util.Set; @@ -43,18 +44,27 @@ public class InferFilterNotNull extends OneRewriteRuleFactory { @Override public Rule build() { return logicalFilter() - .when(filter -> filter.getConjuncts().stream().noneMatch(expr -> expr.isGeneratedIsNotNull)) + .when(filter -> filter.getConjuncts().stream() + .filter(Not.class::isInstance) + .map(Not.class::cast) + .noneMatch(Not::isGeneratedIsNotNull)) .thenApply(ctx -> { LogicalFilter<Plan> filter = ctx.root; Set<Expression> predicates = filter.getConjuncts(); - Set<Expression> isNotNull = ExpressionUtils.inferNotNull(predicates, ctx.cascadesContext); - if (isNotNull.isEmpty() || predicates.containsAll(isNotNull)) { + Set<Expression> isNotNulls = ExpressionUtils.inferNotNull(predicates, ctx.cascadesContext); + ImmutableSet.Builder<Expression> needGenerateNotNullsBuilder = ImmutableSet.builder(); + for (Expression isNotNull : isNotNulls) { + if (!predicates.contains(isNotNull)) { + needGenerateNotNullsBuilder.add(((Not) isNotNull).withGeneratedIsNotNull(true)); + } + } + Set<Expression> needGenerateNotNulls = needGenerateNotNullsBuilder.build(); + if (needGenerateNotNulls.isEmpty()) { return null; } - Builder<Expression> builder = ImmutableSet.<Expression>builder() - .addAll(predicates) - .addAll(isNotNull); - return PlanUtils.filter(builder.build(), filter.child()).get(); + Set<Expression> conjuncts = Streams.concat(predicates.stream(), needGenerateNotNulls.stream()) + .collect(ImmutableSet.toImmutableSet()); + return PlanUtils.filter(conjuncts, filter.child()).get(); }).toRule(RuleType.INFER_FILTER_NOT_NULL); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Expression.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Expression.java index 246cbbf8969..a0a88848794 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Expression.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Expression.java @@ -59,7 +59,6 @@ import java.util.Set; public abstract class Expression extends AbstractTreeNode<Expression> implements ExpressionTrait { public static final String DEFAULT_EXPRESSION_NAME = "expression"; // Mask this expression is generated by rule, should be removed. - public boolean isGeneratedIsNotNull = false; protected Optional<String> exprName = Optional.empty(); private final int depth; private final int width; diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Not.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Not.java index 7c7ec5283bb..44197ae617d 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Not.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Not.java @@ -38,12 +38,24 @@ public class Not extends Expression implements UnaryExpression, ExpectsInputType public static final List<DataType> EXPECTS_INPUT_TYPES = ImmutableList.of(BooleanType.INSTANCE); + private final boolean isGeneratedIsNotNull; + public Not(Expression child) { + this(child, false); + } + + public Not(Expression child, boolean isGeneratedIsNotNull) { super(ImmutableList.of(child)); + this.isGeneratedIsNotNull = isGeneratedIsNotNull; } - private Not(List<Expression> child) { + private Not(List<Expression> child, boolean isGeneratedIsNotNull) { super(child); + this.isGeneratedIsNotNull = isGeneratedIsNotNull; + } + + public boolean isGeneratedIsNotNull() { + return isGeneratedIsNotNull; } @Override @@ -70,12 +82,13 @@ public class Not extends Expression implements UnaryExpression, ExpectsInputType return false; } Not other = (Not) o; - return Objects.equals(child(), other.child()); + return Objects.equals(child(), other.child()) + && isGeneratedIsNotNull == other.isGeneratedIsNotNull; } @Override public int hashCode() { - return child().hashCode(); + return Objects.hash(child().hashCode(), isGeneratedIsNotNull); } @Override @@ -91,9 +104,11 @@ public class Not extends Expression implements UnaryExpression, ExpectsInputType @Override public Not withChildren(List<Expression> children) { Preconditions.checkArgument(children.size() == 1); - Not not = new Not(children); - not.isGeneratedIsNotNull = this.isGeneratedIsNotNull; - return not; + return new Not(children, isGeneratedIsNotNull); + } + + public Not withGeneratedIsNotNull(boolean isGeneratedIsNotNull) { + return new Not(children, isGeneratedIsNotNull); } @Override diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/DeleteFromCommand.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/DeleteFromCommand.java index ecca68fa672..ac2e4987715 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/DeleteFromCommand.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/DeleteFromCommand.java @@ -19,7 +19,9 @@ package org.apache.doris.nereids.trees.plans.commands; import org.apache.doris.analysis.Expr; import org.apache.doris.analysis.Predicate; +import org.apache.doris.analysis.SetVar; import org.apache.doris.analysis.SlotRef; +import org.apache.doris.analysis.StringLiteral; import org.apache.doris.catalog.Column; import org.apache.doris.catalog.Database; import org.apache.doris.catalog.Env; @@ -32,6 +34,7 @@ import org.apache.doris.nereids.NereidsPlanner; import org.apache.doris.nereids.analyzer.UnboundRelation; import org.apache.doris.nereids.exceptions.AnalysisException; import org.apache.doris.nereids.glue.LogicalPlanAdapter; +import org.apache.doris.nereids.rules.RuleType; import org.apache.doris.nereids.trees.expressions.And; import org.apache.doris.nereids.trees.expressions.ComparisonPredicate; import org.apache.doris.nereids.trees.expressions.Expression; @@ -54,9 +57,11 @@ import org.apache.doris.nereids.util.Utils; import org.apache.doris.qe.ConnectContext; import org.apache.doris.qe.SessionVariable; import org.apache.doris.qe.StmtExecutor; +import org.apache.doris.qe.VariableMgr; import com.google.common.base.Preconditions; import com.google.common.collect.Lists; +import org.apache.commons.lang3.StringUtils; import java.util.List; import java.util.Optional; @@ -90,7 +95,7 @@ public class DeleteFromCommand extends Command implements ForwardWithSync { @Override public void run(ConnectContext ctx, StmtExecutor executor) throws Exception { LogicalPlanAdapter logicalPlanAdapter = new LogicalPlanAdapter(logicalQuery, ctx.getStatementContext()); - turnOffForbidUnknownStats(ctx.getSessionVariable()); + updateSessionVariableForDelete(ctx.getSessionVariable()); NereidsPlanner planner = new NereidsPlanner(ctx.getStatementContext()); planner.plan(logicalPlanAdapter, ctx.getSessionVariable().toThrift()); executor.setPlanner(planner); @@ -173,9 +178,22 @@ public class DeleteFromCommand extends Command implements ForwardWithSync { Lists.newArrayList(relation.getPartNames()), predicates, ctx.getState()); } - private void turnOffForbidUnknownStats(SessionVariable sessionVariable) { + private void updateSessionVariableForDelete(SessionVariable sessionVariable) { sessionVariable.setIsSingleSetVar(true); - sessionVariable.setForbidUnownColStats(false); + try { + // turn off forbid unknown col stats + VariableMgr.setVar(sessionVariable, + new SetVar(SessionVariable.FORBID_UNKNOWN_COLUMN_STATS, new StringLiteral("false"))); + // disable eliminate not null rule + List<String> disableRules = Lists.newArrayList( + RuleType.ELIMINATE_NOT_NULL.name(), RuleType.INFER_FILTER_NOT_NULL.name()); + disableRules.addAll(sessionVariable.getDisableNereidsRuleNames()); + VariableMgr.setVar(sessionVariable, + new SetVar(SessionVariable.DISABLE_NEREIDS_RULES, + new StringLiteral(StringUtils.join(disableRules, ",")))); + } catch (Exception e) { + throw new AnalysisException("set session variable by delete from command failed", e); + } } private void checkColumn(Set<String> tableColumns, SlotReference slotReference, OlapTable table) { diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/ExpressionUtils.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/ExpressionUtils.java index 1a16e61a1b4..a111edf7003 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/ExpressionUtils.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/ExpressionUtils.java @@ -574,11 +574,8 @@ public class ExpressionUtils { */ public static Set<Expression> inferNotNull(Set<Expression> predicates, CascadesContext cascadesContext) { return inferNotNullSlots(predicates, cascadesContext).stream() - .map(slot -> { - Not isNotNull = new Not(new IsNull(slot)); - isNotNull.isGeneratedIsNotNull = true; - return isNotNull; - }).collect(Collectors.toSet()); + .map(slot -> new Not(new IsNull(slot), false)) + .collect(Collectors.toSet()); } /** @@ -589,11 +586,8 @@ public class ExpressionUtils { CascadesContext cascadesContext) { return inferNotNullSlots(predicates, cascadesContext).stream() .filter(slots::contains) - .map(slot -> { - Not isNotNull = new Not(new IsNull(slot)); - isNotNull.isGeneratedIsNotNull = true; - return isNotNull; - }).collect(Collectors.toSet()); + .map(slot -> new Not(new IsNull(slot), true)) + .collect(Collectors.toSet()); } public static <E extends Expression> List<E> flatExpressions(List<List<E>> expressions) { diff --git a/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java b/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java index 0124efc4299..207c48e1f20 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java +++ b/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java @@ -2391,7 +2391,7 @@ public class SessionVariable implements Serializable, Writable { return forbidUnknownColStats; } - public void setForbidUnownColStats(boolean forbid) { + public void setForbidUnknownColStats(boolean forbid) { forbidUnknownColStats = forbid; } diff --git a/fe/fe-core/src/test/java/org/apache/doris/nereids/rules/rewrite/InferAggNotNullTest.java b/fe/fe-core/src/test/java/org/apache/doris/nereids/rules/rewrite/InferAggNotNullTest.java index dcb9b801a9d..7d20c2f22a6 100644 --- a/fe/fe-core/src/test/java/org/apache/doris/nereids/rules/rewrite/InferAggNotNullTest.java +++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/rules/rewrite/InferAggNotNullTest.java @@ -18,6 +18,7 @@ package org.apache.doris.nereids.rules.rewrite; import org.apache.doris.nereids.trees.expressions.Alias; +import org.apache.doris.nereids.trees.expressions.Not; import org.apache.doris.nereids.trees.expressions.functions.agg.Count; import org.apache.doris.nereids.trees.plans.logical.LogicalOlapScan; import org.apache.doris.nereids.trees.plans.logical.LogicalPlan; @@ -44,7 +45,8 @@ class InferAggNotNullTest implements MemoPatternMatchSupported { .applyTopDown(new InferAggNotNull()) .matches( logicalAggregate( - logicalFilter().when(filter -> filter.getConjuncts().stream().allMatch(e -> e.isGeneratedIsNotNull)) + logicalFilter().when(filter -> filter.getConjuncts().stream() + .allMatch(e -> ((Not) e).isGeneratedIsNotNull())) ) ); } diff --git a/regression-test/data/nereids_rules_p0/eliminate_not_null/eliminate_not_null.out b/regression-test/data/nereids_rules_p0/eliminate_not_null/eliminate_not_null.out index a238db46cec..8f1bab13986 100644 --- a/regression-test/data/nereids_rules_p0/eliminate_not_null/eliminate_not_null.out +++ b/regression-test/data/nereids_rules_p0/eliminate_not_null/eliminate_not_null.out @@ -1,38 +1,38 @@ -- This file is automatically generated. You should know what you did if you want to edit this -- !eliminate_not_null_basic_comparison -- PhysicalResultSink ---filter(( not score IS NULL) and (t.score > 13)) +--filter((t.score > 13)) ----PhysicalOlapScan[t] -- !eliminate_not_null_in_clause -- PhysicalResultSink ---filter(( not id IS NULL) and id IN (1, 2, 3)) +--filter(id IN (1, 2, 3)) ----PhysicalOlapScan[t] -- !eliminate_not_null_not_equal -- PhysicalResultSink ---filter(( not (score = 13)) and ( not score IS NULL)) +--filter(( not (score = 13))) ----PhysicalOlapScan[t] -- !eliminate_not_null_string_function -- PhysicalResultSink ---filter(( not name IS NULL) and (length(name) > 0)) +--filter((length(name) > 0)) ----PhysicalOlapScan[t] -- !eliminate_not_null_aggregate -- PhysicalResultSink --hashAgg[LOCAL] -----filter(( not score IS NULL) and (t.score > 0)) +----filter((t.score > 0)) ------PhysicalOlapScan[t] -- !eliminate_not_null_between -- PhysicalResultSink ---filter(( not score IS NULL) and (t.score <= 10) and (t.score >= 1)) +--filter((t.score <= 10) and (t.score >= 1)) ----PhysicalOlapScan[t] -- !eliminate_not_null_math_function -- PhysicalResultSink ---filter(( not score IS NULL) and (abs(score) = 5)) +--filter((abs(score) = 5)) ----PhysicalOlapScan[t] -- !eliminate_not_null_complex_logic -- @@ -42,7 +42,7 @@ PhysicalResultSink -- !eliminate_not_null_date_function -- PhysicalResultSink ---filter(( not name IS NULL) and (year(cast(name as DATEV2)) = 2022)) +--filter((year(cast(name as DATEV2)) = 2022)) ----PhysicalOlapScan[t] -- !eliminate_not_null_with_subquery -- --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
