Util.first(filterRel.getCluster().getPlanner().getExecutor(), RexUtil.EXECUTOR); final RexSimplify simplify = new RexSimplify(rexBuilder, true, executor); final RexNode x = simplify.simplifyAnds(listBuilder.build()); if (x.isAlwaysFalse()) {
private void simplifyList(List<RexNode> terms, RexUnknownAs unknownAs) { unknownAs = UNKNOWN; // TODO for (int i = 0; i < terms.size(); i++) { terms.set(i, simplify(terms.get(i), unknownAs)); } }
private RexNode simplify(RexNode e) { final RexSimplify simplify = new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, RexUtil.EXECUTOR) .withParanoid(true); return simplify.simplifyUnknownAs(e, RexUnknownAs.UNKNOWN); }
/** As {@link #simplify(RexNode)}, but specifying how UNKNOWN values are to be * treated. * * <p>If UNKNOWN is treated as FALSE, this may allow certain additional * simplifications. A result of UNKNOWN may yield FALSE, however it may still * yield UNKNOWN. (If the simplified expression has type BOOLEAN NOT NULL, * then of course it can only return FALSE.) */ public RexNode simplifyUnknownAs(RexNode e, RexUnknownAs unknownAs) { return verify(e, unknownAs, simplifier -> simplifier.simplify(e, unknownAs)); }
/** * Simplifies a boolean expression, leaving UNKNOWN values as UNKNOWN, and * using the default executor. * * @deprecated Create a {@link RexSimplify}, then call its * {@link RexSimplify#simplify(RexNode, RexUnknownAs)} method. */ @Deprecated // to be removed before 2.0 public static RexNode simplify(RexBuilder rexBuilder, RexNode e) { return new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, EXECUTOR) .simplify(e); }
public void setUp() { typeFactory = new JavaTypeFactoryImpl(RelDataTypeSystem.DEFAULT); rexBuilder = new RexBuilder(typeFactory); executor = new RexExecutorImpl(new DummyTestDataContext()); simplify = new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, executor) .withParanoid(true); trueLiteral = rexBuilder.makeLiteral(true); falseLiteral = rexBuilder.makeLiteral(false); nonNullableInt = typeFactory.createSqlType(SqlTypeName.INTEGER); nullableInt = typeFactory.createTypeWithNullability(nonNullableInt, true); nullInt = rexBuilder.makeNullLiteral(nullableInt); nonNullableBool = typeFactory.createSqlType(SqlTypeName.BOOLEAN); nullableBool = typeFactory.createTypeWithNullability(nonNullableBool, true); nullBool = rexBuilder.makeNullLiteral(nullableBool); nonNullableVarchar = typeFactory.createSqlType(SqlTypeName.VARCHAR); nullableVarchar = typeFactory.createTypeWithNullability(nonNullableVarchar, true); nullVarchar = rexBuilder.makeNullLiteral(nullableVarchar); }
/** Simplifies a boolean expression, always preserving its type and its * nullability. * * <p>This is useful if you are simplifying expressions in a * {@link Project}. * * @deprecated Use {@link RexSimplify#simplifyPreservingType(RexNode)}, * which allows you to specify an {@link RexExecutor}. */ @Deprecated // to be removed before 2.0 public static RexNode simplifyPreservingType(RexBuilder rexBuilder, RexNode e) { return new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, EXECUTOR) .simplifyPreservingType(e); }
private void simplifyAndTerms(List<RexNode> terms) { RexSimplify simplify = this; for (int i = 0; i < terms.size(); i++) { RexNode t = terms.get(i); if (Predicate.of(t) == null) { continue; } terms.set(i, simplify.simplify(t, UNKNOWN)); RelOptPredicateList newPredicates = simplify.predicates.union(rexBuilder, RelOptPredicateList.of(rexBuilder, terms.subList(i, i + 1))); simplify = simplify.withPredicates(newPredicates); } for (int i = 0; i < terms.size(); i++) { RexNode t = terms.get(i); if (Predicate.of(t) != null) { continue; } terms.set(i, simplify.simplify(t, UNKNOWN)); } }
call.getMetadataQuery().getPulledUpPredicates(filter.getInput()); final RexSimplify simplify = new RexSimplify(rexBuilder, predicates, executor); final RexNode cond = simplify.simplifyUnknownAsFalse(filter.getCondition()); for (RexNode e : RelOptUtil.conjunctions(cond)) { DruidJsonFilter druidJsonFilter = DruidJsonFilter
/** As {@link #simplify(RexNode)}, but for a boolean expression * for which a result of UNKNOWN will be treated as FALSE. * * <p>Use this form for expressions on a WHERE, ON, HAVING or FILTER(WHERE) * clause. * * <p>This may allow certain additional simplifications. A result of UNKNOWN * may yield FALSE, however it may still yield UNKNOWN. (If the simplified * expression has type BOOLEAN NOT NULL, then of course it can only return * FALSE.) */ public final RexNode simplifyUnknownAsFalse(RexNode e) { return simplifyUnknownAs(e, FALSE); }
/** Returns a RexSimplify the same as this but which verifies that * the expression before and after simplification are equivalent. * * @see #verify */ public RexSimplify withParanoid(boolean paranoid) { return paranoid == this.paranoid ? this : new RexSimplify(rexBuilder, predicates, defaultUnknownAs, predicateElimination, paranoid, executor); }
RexSimplify condSimplifier = this.withPredicates(RelOptPredicateList.EMPTY); RexSimplify valueSimplifier = this; RelDataType caseType = call.getType(); RexNode newCond = condSimplifier.simplify(inputBranch.cond, RexUnknownAs.FALSE); if (newCond.isAlwaysFalse()) { RexNode newValue = valueSimplifier.simplify(inputBranch.value, unknownAs); && isSafeExpression(newCond)) { CaseBranch branch = generateBranch(conditionNeedsSimplify, condSimplifier, lastBranch); if (!branch.cond.isAlwaysFalse()) { CaseBranch branch = generateBranch(conditionNeedsSimplify, condSimplifier, lastBranch); if (!branch.cond.isAlwaysFalse()) { branches.add(branch); if (sameTypeOrNarrowsNullability(caseType, value.getType())) { return value; } else { final RexNode result = simplifyBooleanCase(rexBuilder, branches, unknownAs, caseType); if (result != null) { if (sameTypeOrNarrowsNullability(caseType, result.getType())) { return simplify(result, unknownAs); } else { RexNode simplified = simplify(result, UNKNOWN);
@Deprecated // to be removed before 2.0 public static RexNode simplifyOrs(RexBuilder rexBuilder, List<RexNode> terms) { return new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, EXECUTOR) .simplifyOrs(terms); }
@Deprecated // to be removed before 2.0 public static RexNode simplifyAnd2(RexBuilder rexBuilder, List<RexNode> terms, List<RexNode> notTerms) { return new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, EXECUTOR) .simplifyAnd2(terms, notTerms); }
private void checkSimplifyFilter(RexNode node, RelOptPredicateList predicates, String expected) { final RexNode simplified = simplify.withPredicates(predicates) .simplifyUnknownAs(node, RexUnknownAs.FALSE); assertThat(simplified.toString(), equalTo(expected)); }
@Deprecated // to be removed before 2.0 public static RexNode simplifyOr(RexBuilder rexBuilder, RexCall call) { return new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, EXECUTOR) .simplifyOr(call); }
@Deprecated // to be removed before 2.0 public static RexNode simplifyAnd2ForUnknownAsFalse(RexBuilder rexBuilder, List<RexNode> terms, List<RexNode> notTerms) { return new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, EXECUTOR) .simplifyAnd2ForUnknownAsFalse(terms, notTerms); }
@Deprecated // to be removed before 2.0 public static RexNode simplifyAnd(RexBuilder rexBuilder, RexCall e, boolean unknownAsFalse) { return new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, EXECUTOR) .simplifyAnd(e, RexUnknownAs.falseIf(unknownAsFalse)); }
/** * Combines predicates AND, optimizes, and returns null if the result is * always false. * * <p>The expression is simplified on the assumption that an UNKNOWN value * is always treated as FALSE. Therefore the simplified expression may * sometimes evaluate to FALSE where the original expression would evaluate to * UNKNOWN. * * @param predicates Filter condition predicates * @return simplified conjunction of predicates for the filter, null if always false */ public RexNode simplifyFilterPredicates(Iterable<? extends RexNode> predicates) { final RexNode simplifiedAnds = withPredicateElimination(Bug.CALCITE_2401_FIXED) .simplifyAnds(predicates, FALSE); if (simplifiedAnds.isAlwaysFalse()) { return null; } // Remove cast of BOOLEAN NOT NULL to BOOLEAN or vice versa. Filter accepts // nullable and not-nullable conditions, but a CAST might get in the way of // other rewrites. return removeNullabilityCast(simplifiedAnds); }
/** Creates a {@link Filter} of a list of * predicates. * * <p>The predicates are combined using AND, * and optimized in a similar way to the {@link #and} method. * If the result is TRUE no filter is created. */ public RelBuilder filter(Iterable<? extends RexNode> predicates) { final RexNode simplifiedPredicates = simplifier.simplifyFilterPredicates(predicates); if (simplifiedPredicates == null) { return empty(); } if (!simplifiedPredicates.isAlwaysTrue()) { final Frame frame = stack.pop(); final RelNode filter = filterFactory.createFilter(frame.rel, simplifiedPredicates); stack.push(new Frame(filter, frame.fields)); } return this; }