HepRelVertex(RelNode rel) { super( rel.getCluster(), rel.getTraitSet()); currentRel = rel; }
/** * Creates an expression with which to reference the expression whose * offset in its from-list is {@code offset}. */ RexNode lookup( int offset, LookupContext lookupContext) { Pair<RelNode, Integer> pair = lookupContext.findRel(offset); return rexBuilder.makeRangeReference( pair.left.getRowType(), pair.right, false); }
public void rewriteGeneric(RelNode rel) { RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs()); List<RelNode> oldInputs = rel.getInputs(); for (int i = 0; i < oldInputs.size(); ++i) { newRel.replaceInput( i, getNewForOldRel(oldInputs.get(i))); } setNewForOldRel(rel, newRel); }
public void flatten( List<RelNode> rels, int systemFieldCount, int[] start, List<Pair<RelNode, Integer>> relOffsetList) { for (RelNode rel : rels) { if (leaves.contains(rel)) { relOffsetList.add( Pair.of(rel, start[0])); start[0] += rel.getRowType().getFieldCount(); } else { if (rel instanceof JoinRel || rel instanceof AggregateRel) { start[0] += systemFieldCount; } flatten( rel.getInputs(), systemFieldCount, start, relOffsetList); } } }
((ProjectRel) insertRel.getInput(0)).getProjects(); if (insertRel.getInput(0).getInput(0) instanceof ProjectRel) { level2InsertExprs = ((ProjectRel) insertRel.getInput(0).getInput(0)) .getProjects(); JoinRel joinRel = (JoinRel) mergeSourceRel.getInput(0); int nSourceFields = joinRel.getLeft().getRowType().getFieldCount(); List<RexNode> projects = new ArrayList<RexNode>(); for (int level1Idx = 0; level1Idx < nLevel1Exprs; level1Idx++) {
rightRel.getCluster(), leftRel, rightRel, final int leftCount = leftRel.getRowType().getFieldCount(); final int rightCount = rightRel.getRowType().getFieldCount(); if (!containsGet(joinCond)) { joinCond = pushDownJoinConditions( leftRel.getRowType().getFieldList(); leftRel = RelOptUtil.createProject( leftRel, rightRel.getRowType().getFieldList(); final int newLeftCount = leftCount + extraLeftExprs.size(); rightRel = RelOptUtil.createProject(
private void decorrelateInputWithValueGenerator( RelNode rel) { assert rel.getInputs().size() == 1; RelNode oldChildRel = rel.getInput(0); RelNode newChildRel = mapOldToNewRel.get(oldChildRel); int leftChildOutputCount = newLeftChildRel.getRowType().getFieldCount(); RelNode joinRel = new JoinRel( rel.getCluster(), newLeftChildRel, valueGenRel,
private boolean fixUpInputs(RelNode rel) { List<RelNode> inputs = rel.getInputs(); int i = -1; int changeCount = 0; for (RelNode input : inputs) { ++i; if (input instanceof RelSubset) { final RelSubset subset = (RelSubset) input; RelSubset newSubset = canonize(subset); if (newSubset != subset) { rel.replaceInput(i, newSubset); if (subset.set != newSubset.set) { subset.set.parents.remove(rel); newSubset.set.parents.add(rel); } changeCount++; } } } return changeCount > 0; }
public static <T extends RelNode> T addTrait( T rel, RelTrait trait) { //noinspection unchecked return (T) rel.copy( rel.getTraitSet().replace(trait), (List) rel.getInputs()); }
RelNode rel, List<Pair<String, Object>> values) { String tagName = rel.getRelTypeName(); xmlOutput.beginBeginTag(tagName); xmlOutput.attribute("id", rel.getId() + ""); for (RelNode input : rel.getInputs()) { input.explain(this);
public RelNode onRegister(RelOptPlanner planner) { List<RelNode> oldInputs = getInputs(); List<RelNode> inputs = new ArrayList<RelNode>(oldInputs.size()); for (final RelNode input : oldInputs) { RelNode e = planner.ensureRegistered(input, null); if (e != input) { // TODO: change 'equal' to 'eq', which is stronger. assert RelOptUtil.equal( "rowtype of rel before registration", input.getRowType(), "rowtype of rel after registration", e.getRowType(), true); } inputs.add(e); } RelNode r = this; if (!Util.equalShallow(oldInputs, inputs)) { r = copy(getTraitSet(), inputs); } r.recomputeDigest(); assert r.isValid(true); return r; }
private static List<RelSubset> inputSubsets(RelNode parent) { //noinspection unchecked return (List<RelSubset>) (List) parent.getInputs(); }
/** * Visits a particular child of a parent. */ protected RelNode visitChild(RelNode parent, int i, RelNode child) { Stacks.push(stack, parent); try { RelNode child2 = child.accept(this); if (child2 != child) { final List<RelNode> newInputs = new ArrayList<RelNode>(parent.getInputs()); newInputs.set(i, child2); return parent.copy(parent.getTraitSet(), newInputs); } return parent; } finally { Stacks.pop(stack, parent); } }
public RelNode convert(RelNode rel) { return new PhysToIteratorConverter( rel.getCluster(), rel); } });
int parentOrdinal = operand.getParent().ordinalInRule; RelNode parentRel = rels[parentOrdinal]; List<RelNode> inputs = parentRel.getInputs(); if (operand.ordinalInParent < inputs.size()) { RelSubset subset = (RelSubset) rel.getInput( previousOperand.ordinalInParent); List<RelNode> inputRels = input.set.getRelsFromAllSubsets();
"select deptno, count(*) from emp where deptno > 10 " + "group by deptno having count(*) = 0"); rel.getCluster().setMetadataProvider( ChainedRelMetadataProvider.of( ImmutableList.of( ColTypeImpl.SOURCE, rel.getCluster().getMetadataProvider()))); assertThat(rel.metadata(ColType.class).getColType(0), equalTo("DEPTNO-rel")); assertThat(rel.metadata(ColType.class).getColType(1), equalTo("EXPR$1-rel")); final RelNode input = rel.getInput(0); assertThat(input, instanceOf(AggregateRel.class)); assertThat(input.metadata(ColType.class).getColType(0), equalTo("DEPTNO-agg")); assertThat(input.metadata(ColType.class).getColType(0), equalTo("DEPTNO-agg")); assertThat(buf.size(), equalTo(4)); final RelOptPlanner planner = rel.getCluster().getPlanner(); rel.getCluster().setMetadataProvider( new CachingRelMetadataProvider( rel.getCluster().getMetadataProvider(), planner)); assertThat(input.metadata(ColType.class).getColType(0), equalTo("DEPTNO-agg")); assertThat(buf.size(), equalTo(5)); assertThat(input.metadata(ColType.class).getColType(0),
private void explainInputs(List<RelNode> inputs) { for (RelNode input : inputs) { input.explain(this); } }
private RelNode buildFinalPlan(HepRelVertex vertex) { RelNode rel = vertex.getCurrentRel(); notifyChosen(rel); // Recursively process children, replacing this rel's inputs // with corresponding child rels. List<RelNode> inputs = rel.getInputs(); for (int i = 0; i < inputs.size(); ++i) { RelNode child = inputs.get(i); if (!(child instanceof HepRelVertex)) { // Already replaced. continue; } child = buildFinalPlan((HepRelVertex) child); rel.replaceInput(i, child); rel.recomputeDigest(); } return rel; }
protected RelTraitSet getDesiredRootTraitSet(RelNode rootRel) { // Make sure non-CallingConvention traits, if any, are preserved return rootRel.getTraitSet() .replace(resultConvention); }
final RelNode seek = converted.left.getInput(0); // fragile final int keyCount = leftKeys.size(); final List<Integer> args = ImmutableIntList.range(0, keyCount);