&& call.getOperands().length == leftKeys.size(); rexComparison = RexUtil.composeConjunction( rexBuilder, Iterables.transform(
list.add(equalsCall); return RexUtil.composeConjunction(rexBuilder, list, 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); }
/** * If the filter list passed in is non-empty, creates a FilterRel on top of * the existing RelNode; otherwise, just returns the RelNode * * @param rexBuilder rex builder * @param rel the RelNode that the filter will be put on top of * @param filters list of filters * @return new RelNode or existing one if no filters */ private RelNode createFilterOnRel( RexBuilder rexBuilder, RelNode rel, List<RexNode> filters) { RexNode andFilters = RexUtil.composeConjunction(rexBuilder, filters, false); if (andFilters.isAlwaysTrue()) { return rel; } return filterFactory.createFilter(rel, andFilters); }
/** * AND's two predicates together, either of which may be null, removing * redundant filters. * * @param rexBuilder rexBuilder used to construct AND'd RexNode * @param pred1 first predicate * @param pred2 second predicate * @return AND'd predicate or individual predicates if one is null */ public static RexNode unionPreds( RexBuilder rexBuilder, RexNode pred1, RexNode pred2) { final List<RexNode> unionList = new ArrayList<RexNode>(); final Set<String> strings = new HashSet<String>(); for (RexNode rex : RelOptUtil.conjunctions(pred1)) { if (strings.add(rex.toString())) { unionList.add(rex); } } for (RexNode rex2 : RelOptUtil.conjunctions(pred2)) { if (strings.add(rex2.toString())) { unionList.add(rex2); } } return RexUtil.composeConjunction(rexBuilder, unionList, true); }
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, not(rexBuilder)), false); }
public static RexNode splitCorrelatedFilterCondition( FilterRel filterRel, List<RexInputRef> joinKeys, List<RexNode> correlatedJoinKeys) { List<RexNode> nonEquiList = new ArrayList<RexNode>(); splitCorrelatedFilterCondition( filterRel, filterRel.getCondition(), joinKeys, correlatedJoinKeys, nonEquiList); // Convert the remainders into a list that are AND'ed together. return RexUtil.composeConjunction( filterRel.getCluster().getRexBuilder(), nonEquiList, true); }
/** * Takes the difference between two predicates, removing from the first any * predicates also in the second * * @param rexBuilder rexBuilder used to construct AND'd RexNode * @param pred1 first predicate * @param pred2 second predicate * @return MINUS'd predicate list */ public static RexNode minusPreds( RexBuilder rexBuilder, RexNode pred1, RexNode pred2) { List<RexNode> list1 = RelOptUtil.conjunctions(pred1); List<RexNode> list2 = RelOptUtil.conjunctions(pred2); List<RexNode> minusList = new ArrayList<RexNode>(); for (RexNode rex1 : list1) { boolean add = true; for (RexNode rex2 : list2) { if (rex2.toString().compareTo(rex1.toString()) == 0) { add = false; break; } } if (add) { minusList.add(rex1); } } return RexUtil.composeConjunction(rexBuilder, minusList, true); }
public static RexNode splitCorrelatedFilterCondition( FilterRel filterRel, List<RexNode> joinKeys, List<RexNode> correlatedJoinKeys, boolean extractCorrelatedFieldAccess) { List<RexNode> nonEquiList = new ArrayList<RexNode>(); splitCorrelatedFilterCondition( filterRel, filterRel.getCondition(), joinKeys, correlatedJoinKeys, nonEquiList, extractCorrelatedFieldAccess); // Convert the remainders into a list that are AND'ed together. return RexUtil.composeConjunction( filterRel.getCluster().getRexBuilder(), nonEquiList, true); }
public Double getSelectivity(AggregateRelBase rel, RexNode predicate) { List<RexNode> notPushable = new ArrayList<RexNode>(); List<RexNode> pushable = new ArrayList<RexNode>(); RelOptUtil.splitFilters( rel.getGroupSet(), predicate, pushable, notPushable); final RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); RexNode childPred = RexUtil.composeConjunction(rexBuilder, pushable, true); Double selectivity = RelMetadataQuery.getSelectivity( rel.getChild(), childPred); if (selectivity == null) { return null; } else { RexNode pred = RexUtil.composeConjunction(rexBuilder, notPushable, true); return selectivity * RelMdUtil.guessSelectivity(pred); } }
final RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); RexNode childPreds = RexUtil.composeConjunction(rexBuilder, pushable, true); } else { RexNode preds = RexUtil.composeConjunction(rexBuilder, notPushable, true); return distinctRowCount * RelMdUtil.guessSelectivity(preds);
public RelOptPredicateList getPredicates(JoinRelBase join) { RexBuilder rB = join.getCluster().getRexBuilder(); RelNode left = join.getInput(0); RelNode right = join.getInput(1); RelOptPredicateList leftInfo = RelMetadataQuery.getPulledUpPredicates(left); RelOptPredicateList rightInfo = RelMetadataQuery.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 UnionRelBase. * * <p>The pulled up expression is a disjunction of its children's predicates. */ public RelOptPredicateList getPredicates(UnionRelBase union) { RexBuilder rB = union.getCluster().getRexBuilder(); List<RexNode> orList = Lists.newArrayList(); for (RelNode input : union.getInputs()) { RelOptPredicateList info = RelMetadataQuery.getPulledUpPredicates(input); if (!info.pulledUpPredicates.isEmpty()) { orList.addAll( RelOptUtil.disjunctions( RexUtil.composeConjunction(rB, info.pulledUpPredicates, false))); } } if (orList.isEmpty()) { return RelOptPredicateList.EMPTY; } return RelOptPredicateList.of( RelOptUtil.conjunctions(RexUtil.composeDisjunction(rB, orList, false))); }
/** * Creates the condition for a join implementing an IN clause. * * @param bb blackboard to use, bb.root points to the LHS * @param leftKeys LHS of IN * @param rightRel Relational expression on RHS * @return join condition */ private RexNode createJoinConditionForIn( Blackboard bb, List<RexNode> leftKeys, RelNode rightRel) { List<RexNode> joinConditions = new ArrayList<RexNode>(); // right fields appear after the LHS fields. int rightInputOffset = bb.root.getRowType().getFieldCount(); List<RelDataTypeField> rightTypeFields = rightRel.getRowType().getFieldList(); assert leftKeys.size() <= rightTypeFields.size(); for (Ord<RexNode> key : Ord.zip(leftKeys)) { joinConditions.add( rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, key.e, rexBuilder.makeInputRef( rightTypeFields.get(key.i).getType(), rightInputOffset + key.i))); } return RexUtil.composeConjunction(rexBuilder, joinConditions, true); }
public RexNode getEquiCondition(final RelNode left, final RelNode right, final RexBuilder rexBuilder) { final List<RelDataType> leftTypes = RelOptUtil.getFieldTypeList(left.getRowType()); final List<RelDataType> rightTypes = RelOptUtil.getFieldTypeList(right.getRowType()); return RexUtil.composeConjunction(rexBuilder, new AbstractList<RexNode>() { @Override public RexNode get(int index) { final int leftKey = leftKeys.get(index); final int rightKey = rightKeys.get(index); return rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef(leftTypes.get(leftKey), leftKey), rexBuilder.makeInputRef(rightTypes.get(rightKey), leftTypes.size() + rightKey)); } @Override public int size() { return leftKeys.size(); } }, false); }
public Double getSelectivity(ProjectRelBase rel, RexNode predicate) { List<RexNode> notPushable = new ArrayList<RexNode>(); List<RexNode> pushable = new ArrayList<RexNode>(); RelOptUtil.splitFilters( BitSets.range(rel.getRowType().getFieldCount()), predicate, pushable, notPushable); final RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); RexNode childPred = RexUtil.composeConjunction(rexBuilder, pushable, true); RexNode modifiedPred; if (childPred == null) { modifiedPred = null; } else { modifiedPred = RelOptUtil.pushFilterPastProject(childPred, rel); } Double selectivity = RelMetadataQuery.getSelectivity( rel.getChild(), modifiedPred); if (selectivity == null) { return null; } else { RexNode pred = RexUtil.composeConjunction(rexBuilder, notPushable, true); return selectivity * RelMdUtil.guessSelectivity(pred); } }
nonEquiList); return RexUtil.composeConjunction( left.getCluster().getRexBuilder(), nonEquiList, false);
RexUtil.composeConjunction(rexBuilder, pushable, true); RexNode modifiedPred; if (childPred == null) { } else if (!notPushable.isEmpty()) { RexNode preds = RexUtil.composeConjunction(rexBuilder, notPushable, true); distinctRowCount *= RelMdUtil.guessSelectivity(preds);
RelNode curr = lChild; lChild = filterFactory.createFilter(lChild, RexUtil.composeConjunction(rB, preds.leftInferredPredicates, false)); call.getPlanner().onCopy(curr, lChild); RelNode curr = rChild; rChild = filterFactory.createFilter(rChild, RexUtil.composeConjunction(rB, preds.rightInferredPredicates, false)); call.getPlanner().onCopy(curr, rChild);
RelNode rightRel = multiJoin.getJoinFactor(rightFactor); RexNode joinFilters = RexUtil.composeConjunction(rexBuilder, joinFilterList, true);