private void infer(List<RexNode> predicates, Set<String> allExprsDigests, List<RexNode> inferedPredicates, List<RexNode> nonFieldsPredicates, boolean includeEqualityInference, ImmutableBitSet inferringFields) { for (RexNode r : predicates) { if (!includeEqualityInference && equalityPredicates.contains(r.toString())) { continue; } Iterable<Mapping> ms = mappings(r); if (ms.iterator().hasNext()) { for (Mapping m : ms) { RexNode tr = r.accept( new RexPermuteInputsShuttle(m, joinRel.getInput(0), joinRel.getInput(1))); if (inferringFields.contains(RelOptUtil.InputFinder.bits(tr)) && !allExprsDigests.contains(tr.toString()) && !isAlwaysTrue(tr)) { inferedPredicates.add(tr); allExprsDigests.add(tr.toString()); } } } else { if (!isAlwaysTrue(r)) { nonFieldsPredicates.add(r); } } } }
private void infer(List<RexNode> predicates, Set<String> allExprsDigests, List<RexNode> inferedPredicates, List<RexNode> nonFieldsPredicates, boolean includeEqualityInference, ImmutableBitSet inferringFields) { for (RexNode r : predicates) { if (!includeEqualityInference && equalityPredicates.contains(r.toString())) { continue; } Iterable<Mapping> ms = mappings(r); if (ms.iterator().hasNext()) { for (Mapping m : ms) { RexNode tr = r.accept( new RexPermuteInputsShuttle(m, joinRel.getInput(0), joinRel.getInput(1))); if (inferringFields.contains(RelOptUtil.InputFinder.bits(tr)) && !allExprsDigests.contains(tr.toString()) && !isAlwaysTrue(tr)) { inferedPredicates.add(tr); allExprsDigests.add(tr.toString()); } } } else { if (!isAlwaysTrue(r)) { nonFieldsPredicates.add(r); } } } }
0, nSysFields + nFieldsLeft, nFieldsRight); final RexPermuteInputsShuttle rightPermute = new RexPermuteInputsShuttle(rightMapping, joinRel); Mappings.TargetMapping leftMapping = Mappings.createShiftMapping( nSysFields + nFieldsLeft, 0, nSysFields, nFieldsLeft); final RexPermuteInputsShuttle leftPermute = new RexPermuteInputsShuttle(leftMapping, joinRel); final List<RexNode> leftInferredPredicates = new ArrayList<>(); final List<RexNode> rightInferredPredicates = new ArrayList<>();
nSysFields + nFieldsLeft, nSysFields, 0, nFieldsLeft); leftChildPredicates = lPreds.accept( new RexPermuteInputsShuttle(leftMapping, joinRel.getInput(0))); nSysFields + nFieldsLeft, 0, nFieldsRight); rightChildPredicates = rPreds.accept( new RexPermuteInputsShuttle(rightMapping, joinRel.getInput(1)));
0, nSysFields + nFieldsLeft, nFieldsRight); final RexPermuteInputsShuttle rightPermute = new RexPermuteInputsShuttle(rightMapping, joinRel); Mappings.TargetMapping leftMapping = Mappings.createShiftMapping( nSysFields + nFieldsLeft, 0, nSysFields, nFieldsLeft); final RexPermuteInputsShuttle leftPermute = new RexPermuteInputsShuttle(leftMapping, joinRel); final List<RexNode> leftInferredPredicates = new ArrayList<>(); final List<RexNode> rightInferredPredicates = new ArrayList<>();
nSysFields + nFieldsLeft, nSysFields, 0, nFieldsLeft); leftChildPredicates = lPreds.accept( new RexPermuteInputsShuttle(leftMapping, joinRel.getInput(0))); nSysFields + nFieldsLeft, 0, nFieldsRight); rightChildPredicates = rPreds.accept( new RexPermuteInputsShuttle(rightMapping, joinRel.getInput(1)));
final RexVisitor<RexNode> shuttle = new RexPermuteInputsShuttle( mapping, newInputs.toArray(new RelNode[newInputs.size()])); RexNode newConditionExpr = conditionExpr.accept(shuttle);
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r); if (!rCols.isEmpty() && groupKeys.contains(rCols)) { r = r.accept(new RexPermuteInputsShuttle(m, input)); aggPullUpPredicates.add(r);
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r); if (!rCols.isEmpty() && groupKeys.contains(rCols)) { r = r.accept(new RexPermuteInputsShuttle(m, input)); aggPullUpPredicates.add(r);
final RexVisitor<RexNode> shuttle = new RexPermuteInputsShuttle( mapping, newInputs.toArray(new RelNode[newInputs.size()])); RexNode newConditionExpr = conditionExpr.accept(shuttle);
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r); if (columnsMapped.contains(rCols)) { r = r.accept(new RexPermuteInputsShuttle(m, child)); projectPullUpPredicates.add(r);
.map(projExpr -> projExpr.accept(new RexPermuteInputsShuttle(mappingRL, call.rel(1)))) .collect(Collectors.toList()); rightInputPotentialFK = RelOptUtil.InputFinder.bits(swappedTopProjExprs, null).intersects(rightBits); .map(projExpr -> projExpr.accept(new RexPermuteInputsShuttle(mappingLR, call.rel(1)))) .collect(Collectors.toList()); leftInputPotentialFK = RelOptUtil.InputFinder.bits(swappedTopProjExprs, null).intersects(leftBits);
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r); if (columnsMapped.contains(rCols)) { r = r.accept(new RexPermuteInputsShuttle(m, child)); projectPullUpPredicates.add(r);
/** Creates a shuttle with an empty field list. It cannot handle GET calls but * otherwise works OK. */ public static RexPermuteInputsShuttle of(Mappings.TargetMapping mapping) { return new RexPermuteInputsShuttle(mapping, ImmutableList.of()); }
/** Creates a shuttle with an empty field list. It cannot handle GET calls but * otherwise works OK. */ public static RexPermuteInputsShuttle of(Mappings.TargetMapping mapping) { return new RexPermuteInputsShuttle(mapping, ImmutableList.of()); }
private void infer(RexNode predicates, Set<RexNode> allExprs, List<RexNode> inferredPredicates, boolean includeEqualityInference, ImmutableBitSet inferringFields) { for (RexNode r : RelOptUtil.conjunctions(predicates)) { if (!includeEqualityInference && equalityPredicates.contains(r)) { continue; } for (Mapping m : mappings(r)) { RexNode tr = r.accept( new RexPermuteInputsShuttle(m, joinRel.getInput(0), joinRel.getInput(1))); // Filter predicates can be already simplified, so we should work with // simplified RexNode versions as well. It also allows prevent of having // some duplicates in in result pulledUpPredicates RexNode simplifiedTarget = simplify.simplifyFilterPredicates(RelOptUtil.conjunctions(tr)); if (checkTarget(inferringFields, allExprs, tr) && checkTarget(inferringFields, allExprs, simplifiedTarget)) { inferredPredicates.add(simplifiedTarget); allExprs.add(simplifiedTarget); } } } }
private void infer(RexNode predicates, Set<String> allExprsDigests, List<RexNode> inferredPredicates, boolean includeEqualityInference, ImmutableBitSet inferringFields) { for (RexNode r : RelOptUtil.conjunctions(predicates)) { if (!includeEqualityInference && equalityPredicates.contains(r.toString())) { continue; } for (Mapping m : mappings(r)) { RexNode tr = r.accept( new RexPermuteInputsShuttle(m, joinRel.getInput(0), joinRel.getInput(1))); // Filter predicates can be already simplified, so we should work with // simplified RexNode versions as well. It also allows prevent of having // some duplicates in in result pulledUpPredicates RexNode simplifiedTarget = simplify.simplifyFilterPredicates(RelOptUtil.conjunctions(tr)); if (checkTarget(inferringFields, allExprsDigests, tr) && checkTarget(inferringFields, allExprsDigests, simplifiedTarget)) { inferredPredicates.add(simplifiedTarget); allExprsDigests.add(simplifiedTarget.toString()); } } } }
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r); if (groupKeys.contains(rCols)) { r = r.accept(new RexPermuteInputsShuttle(m, input)); aggPullUpPredicates.add(r);
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r); if (groupKeys.contains(rCols)) { r = r.accept(new RexPermuteInputsShuttle(m, input)); aggPullUpPredicates.add(r);
new RexPermuteInputsShuttle(inputMapping, newInput); RexNode newConditionExpr = conditionExpr.accept(shuttle);