RexNode compose(RexBuilder rexBuilder, Iterable<RexNode> exprs) { exprs = Linq4j.asEnumerable(exprs).where(new Predicate1<RexNode>() { public boolean apply(RexNode expr) { return expr != null; } }); return RexUtil.composeConjunction(rexBuilder, exprs, false); }
RexNode compose(RexBuilder rexBuilder, Iterable<RexNode> exprs) { exprs = Linq4j.asEnumerable(exprs).where(new Predicate1<RexNode>() { public boolean apply(RexNode expr) { return expr != null; } }); return RexUtil.composeConjunction(rexBuilder, exprs, false); }
finalResidualPreds.add(RexUtil.composeConjunction(rB, residualPreds, false)); finalResidualPreds.set(j, RexUtil.composeConjunction(rB, Lists.newArrayList( finalResidualPreds.get(j), e.getValue()), false));
public static RexNode splitCorrelatedFilterCondition( Filter filter, List<RexNode> joinKeys, List<RexNode> correlatedJoinKeys, boolean extractCorrelatedFieldAccess) { final List<RexNode> nonEquiList = new ArrayList<>(); splitCorrelatedFilterCondition( filter, filter.getCondition(), joinKeys, correlatedJoinKeys, nonEquiList, extractCorrelatedFieldAccess); // Convert the remainders into a list that are AND'ed together. return RexUtil.composeConjunction( filter.getCluster().getRexBuilder(), nonEquiList, true); }
return RexUtil.composeConjunction( inputs.get(0).getCluster().getRexBuilder(), nonEquiList, false);
finalResidualPreds.add(RexUtil.composeConjunction(rB, residualPreds, false)); finalResidualPreds.set(j, RexUtil.composeConjunction(rB, Lists.newArrayList( finalResidualPreds.get(j), e.getValue()), false));
return RexUtil.composeConjunction( inputs.get(0).getCluster().getRexBuilder(), nonEquiList, false);
/** Infers predicates for a {@link org.apache.calcite.rel.core.Join}. */ public RelOptPredicateList getPredicates(Join join, RelMetadataQuery mq) { RexBuilder rB = join.getCluster().getRexBuilder(); RelNode left = join.getInput(0); RelNode right = join.getInput(1); final RelOptPredicateList leftInfo = mq.getPulledUpPredicates(left); final RelOptPredicateList rightInfo = mq.getPulledUpPredicates(right); JoinConditionBasedPredicateInference jI = new JoinConditionBasedPredicateInference(join, RexUtil.composeConjunction(rB, leftInfo.pulledUpPredicates, false), RexUtil.composeConjunction(rB, rightInfo.pulledUpPredicates, false)); return jI.inferPredicates(false); }
/** Infers predicates for a {@link org.apache.calcite.rel.core.Join}. */ public RelOptPredicateList getPredicates(Join join, RelMetadataQuery mq) { RexBuilder rB = join.getCluster().getRexBuilder(); RelNode left = join.getInput(0); RelNode right = join.getInput(1); final RelOptPredicateList leftInfo = mq.getPulledUpPredicates(left); final RelOptPredicateList rightInfo = mq.getPulledUpPredicates(right); JoinConditionBasedPredicateInference jI = new JoinConditionBasedPredicateInference(join, RexUtil.composeConjunction(rB, leftInfo.pulledUpPredicates, false), RexUtil.composeConjunction(rB, rightInfo.pulledUpPredicates, false)); return jI.inferPredicates(false); }
private static RexNode splitOr( final RexBuilder rexBuilder, RexNode condition, RexNode target) { List<RexNode> targets = RelOptUtil.disjunctions(target); for (RexNode e : RelOptUtil.disjunctions(condition)) { boolean found = removeAll(targets, e); if (!found) { return null; } } return RexUtil.composeConjunction(rexBuilder, Lists.transform(targets, RexUtil.notFn(rexBuilder)), false); }
final RelNode newJoin = rel.copy(rel.getTraitSet(), RexUtil.composeConjunction( relBuilder.getRexBuilder(), conjuncts, false), newLeftInput, newRightInput, rel.getJoinType(), rel.isSemiJoinDone());
@Override public RelBuilder filter(Iterable<? extends RexNode> predicates) { final RexNode x = RexUtil.simplify(cluster.getRexBuilder(), RexUtil.composeConjunction(cluster.getRexBuilder(), predicates, false)); if (!x.isAlwaysTrue()) { final RelNode input = build(); final RelNode filter = HiveRelFactories.HIVE_FILTER_FACTORY.createFilter(input, x); return this.push(filter); } return this; }
node = RexUtil.composeConjunction(rexBuilder, newOperands, false); break; case OR:
@Override public RelBuilder filter(Iterable<? extends RexNode> predicates) { final RexNode x = RexUtil.simplify(cluster.getRexBuilder(), RexUtil.composeConjunction(cluster.getRexBuilder(), predicates, false)); if (!x.isAlwaysTrue()) { final RelNode input = build(); final RelNode filter = HiveRelFactories.HIVE_FILTER_FACTORY.createFilter(input, x); return this.push(filter); } return this; }
filterCondToPushBelowProj = RexUtil.composeConjunction(filter.getCluster().getRexBuilder(), newPartKeyFilConds, true); unPushedFilCondAboveProj = RexUtil.composeConjunction(filter.getCluster().getRexBuilder(), unpushedFilConds, true);
RexUtil.composeConjunction(rexBuilder, nonDeterministicExprs, false)); RexNode newPredicate = RexUtil.composeConjunction(rexBuilder, newConjuncts, false); if (newPredicate.isAlwaysTrue()) { return;
private RexNode convertToStatsCondition(RexNode condition, IndexDescriptor index, IndexCallContext context, RelNode scanRel, List<SqlKind>typesToProcess) { RexBuilder builder = scanRel.getCluster().getRexBuilder(); if (condition.getKind() == SqlKind.AND) { final List<RexNode> conditions = Lists.newArrayList(); for(RexNode pred : RelOptUtil.conjunctions(condition)) { conditions.add(convertToStatsCondition(pred, index, context, scanRel, typesToProcess)); } return RexUtil.composeConjunction(builder, conditions, false); } else if (condition.getKind() == SqlKind.OR) { final List<RexNode> conditions = Lists.newArrayList(); for(RexNode pred : RelOptUtil.disjunctions(condition)) { conditions.add(convertToStatsCondition(pred, index, context, scanRel, typesToProcess)); } return RexUtil.composeDisjunction(builder, conditions, false); } else if (condition instanceof RexCall) { // LIKE operator - convert to a RANGE predicate, if possible if (typesToProcess.contains(SqlKind.LIKE) && ((RexCall) condition).getOperator().getKind() == SqlKind.LIKE) { return convertLikeToRange((RexCall)condition, builder); } else if (typesToProcess.contains(SqlKind.CAST) && hasCastExpression(condition)) { return convertCastForFIdx(((RexCall) condition), index, context, scanRel); } else { return condition; } } return condition; }
RexNode newLeftPredicate = RexUtil.composeConjunction(rexBuilder, newLeftConditions, false); RexNode newRightPredicate = RexUtil.composeConjunction(rexBuilder, newRightConditions, false); if (newLeftPredicate.isAlwaysTrue() && newRightPredicate.isAlwaysTrue()) { return;
rightPushedPredicates, preds.rightInferredPredicates, rChild.getRowType()); RexNode newLeftPredicate = RexUtil.composeConjunction(rB, leftPreds, false); RexNode newRightPredicate = RexUtil.composeConjunction(rB, rightPreds, false); if (newLeftPredicate.isAlwaysTrue() && newRightPredicate.isAlwaysTrue()) { return;
rightPushedPredicates, preds.rightInferredPredicates, rChild.getRowType()); RexNode newLeftPredicate = RexUtil.composeConjunction(rB, leftPreds, false); RexNode newRightPredicate = RexUtil.composeConjunction(rB, rightPreds, false); if (newLeftPredicate.isAlwaysTrue() && newRightPredicate.isAlwaysTrue()) { return;