Java Code Examples for org.apache.calcite.rel.RelNode#replaceInput()

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;
}
 

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);
  }
  RelMdUtil.clearCache(rel);
  rel.recomputeDigest();

  return rel;
}
 

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;
}
 

/** Fallback if none of the other {@code decorrelateRel} methods match. */
public Frame decorrelateRel(RelNode rel) {
	RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs());
	if (rel.getInputs().size() > 0) {
		List<RelNode> oldInputs = rel.getInputs();
		List<RelNode> newInputs = new ArrayList<>();
		for (int i = 0; i < oldInputs.size(); ++i) {
			final Frame frame = getInvoke(oldInputs.get(i));
			if (frame == null || frame.c != null) {
				// if input is not rewritten, or if it produces correlated variables, terminate rewrite
				return null;
			}
			newInputs.add(frame.r);
			newRel.replaceInput(i, frame.r);
		}

		if (!Util.equalShallow(oldInputs, newInputs)) {
			newRel = rel.copy(rel.getTraitSet(), newInputs);
		}
	}
	// the output position should not change since there are no corVars coming from below.
	return new Frame(rel, newRel, null, identityMap(rel.getRowType().getFieldCount()));
}
 

/** Fallback if none of the other {@code decorrelateRel} methods match. */
public Frame decorrelateRel(RelNode rel) {
	RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs());
	if (rel.getInputs().size() > 0) {
		List<RelNode> oldInputs = rel.getInputs();
		List<RelNode> newInputs = new ArrayList<>();
		for (int i = 0; i < oldInputs.size(); ++i) {
			final Frame frame = getInvoke(oldInputs.get(i));
			if (frame == null || frame.c != null) {
				// if input is not rewritten, or if it produces correlated variables, terminate rewrite
				return null;
			}
			newInputs.add(frame.r);
			newRel.replaceInput(i, frame.r);
		}

		if (!Util.equalShallow(oldInputs, newInputs)) {
			newRel = rel.copy(rel.getTraitSet(), newInputs);
		}
	}
	// the output position should not change since there are no corVars coming from below.
	return new Frame(rel, newRel, null, identityMap(rel.getRowType().getFieldCount()));
}
 

private RelNode replace(RelNode original, ForcedRule[] rules, JdbcRelBuilderFactory relBuilderFactory) {
	RelNode p = original;
	for (ForcedRule rule : rules) {
		RelNode updated = rule.apply(p, relBuilderFactory);
		if (updated != null) {
			logger.trace("Rule: " + rule.toString() +
					"\nReplacing:\n" + RelOptUtil.toString(p) +
					"\nWith:\n" + RelOptUtil.toString(updated)
			);
			// Must maintain row types so that nothing explodes
			RelOptUtil.equal(
					"RowType of original", p.getRowType(),
					"RowType of replaced", updated.getRowType(),
					Litmus.THROW
			);
			p = updated;
			break;
		}
	}

	List<RelNode> oldInputs = p.getInputs();
	for (int i = 0; i < oldInputs.size(); i++) {
		RelNode originalInput = oldInputs.get(i);
		RelNode replacedInput = replace(originalInput, rules, relBuilderFactory);
		if (replacedInput != originalInput) {
			p.replaceInput(i, replacedInput);
		}
	}
	return p;
}
 

/**
 * Recursively matches a rule.
 *
 * @param rel             Relational expression
 * @param parent          Parent relational expression
 * @param ordinalInParent Ordinal of relational expression among its
 *                        siblings
 * @return whether match occurred
 */
private boolean matchRecursive(
    RelNode rel,
    RelNode parent,
    int ordinalInParent) {
  List<RelNode> bindings = new ArrayList<RelNode>();
  if (match(
      rule.getOperand(),
      rel,
      bindings)) {
    MockRuleCall call =
        new MockRuleCall(
            this,
            rule.getOperand(),
            bindings.toArray(new RelNode[0]));
    if (rule.matches(call)) {
      rule.onMatch(call);
    }
  }

  if (transformationResult != null) {
    if (parent == null) {
      root = transformationResult;
    } else {
      parent.replaceInput(ordinalInParent, transformationResult);
    }
    return true;
  }

  List<? extends RelNode> children = rel.getInputs();
  for (int i = 0; i < children.size(); ++i) {
    if (matchRecursive(children.get(i), rel, i)) {
      return true;
    }
  }
  return false;
}
 

private void contractVertices(
    HepRelVertex preservedVertex,
    HepRelVertex discardedVertex,
    List<HepRelVertex> parents) {
  if (preservedVertex == discardedVertex) {
    // Nop.
    return;
  }

  RelNode rel = preservedVertex.getCurrentRel();
  updateVertex(preservedVertex, rel);

  // Update specified parents of discardedVertex.
  for (HepRelVertex parent : parents) {
    RelNode parentRel = parent.getCurrentRel();
    List<RelNode> inputs = parentRel.getInputs();
    for (int i = 0; i < inputs.size(); ++i) {
      RelNode child = inputs.get(i);
      if (child != discardedVertex) {
        continue;
      }
      parentRel.replaceInput(i, preservedVertex);
    }
    clearCache(parent);
    graph.removeEdge(parent, discardedVertex);
    graph.addEdge(parent, preservedVertex);
    updateVertex(parent, parentRel);
  }

  // NOTE:  we don't actually do graph.removeVertex(discardedVertex),
  // because it might still be reachable from preservedVertex.
  // Leave that job for garbage collection.

  if (discardedVertex == root) {
    root = preservedVertex;
  }
}
 

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);
}
 

/** Fallback if none of the other {@code decorrelateRel} methods match. */
public Frame decorrelateRel(RelNode rel) {
  RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs());

  if (rel.getInputs().size() > 0) {
    List<RelNode> oldInputs = rel.getInputs();
    List<RelNode> newInputs = new ArrayList<>();
    for (int i = 0; i < oldInputs.size(); ++i) {
      final Frame frame = getInvoke(oldInputs.get(i), rel);
      if (frame == null || !frame.corDefOutputs.isEmpty()) {
        // if input is not rewritten, or if it produces correlated
        // variables, terminate rewrite
        return null;
      }
      newInputs.add(frame.r);
      newRel.replaceInput(i, frame.r);
    }

    if (!Util.equalShallow(oldInputs, newInputs)) {
      newRel = rel.copy(rel.getTraitSet(), newInputs);
    }
  }

  // the output position should not change since there are no corVars
  // coming from below.
  return register(rel, newRel, identityMap(rel.getRowType().getFieldCount()),
      ImmutableSortedMap.of());
}
 

@Override
protected RelNode visitChild(RelNode parent, int i, RelNode child) {

  // Ignore the root node.
  if (null == parent) {
    return super.visitChild(parent, i, child);
  }

  // Ignore non-sort child nodes.
  if (!(child instanceof Sort)) {
    return super.visitChild(parent, i, child);
  }

  // Ignore the sort for the top level SELECT. It's valid to use ORDER BY
  // without FETCH / OFFSET here.
  if (child == topLevelSort) {
    return super.visitChild(parent, i, child);
  }

  // If the child Sort has FETCH and LIMIT clauses, do not touch them.
  Sort childAsSort = (Sort) child;
  if (childAsSort.offset == null &&
      childAsSort.fetch == null) {
    parent.replaceInput(i, childAsSort.getInput());
    return super.visitChild(parent, i, childAsSort.getInput());
  }

  return super.visitChild(parent, i, child);
}
 

/** Fallback if none of the other {@code decorrelateRel} methods match. */
public Frame decorrelateRel(RelNode rel) {
    RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs());

    if (rel.getInputs().size() > 0) {
        List<RelNode> oldInputs = rel.getInputs();
        List<RelNode> newInputs = new ArrayList<>();
        for (int i = 0; i < oldInputs.size(); ++i) {
            final Frame frame = getInvoke(oldInputs.get(i), rel);
            if (frame == null || !frame.corDefOutputs.isEmpty()) {
                // if input is not rewritten, or if it produces correlated
                // variables, terminate rewrite
                return null;
            }
            newInputs.add(frame.r);
            newRel.replaceInput(i, frame.r);
        }

        if (!Util.equalShallow(oldInputs, newInputs)) {
            newRel = rel.copy(rel.getTraitSet(), newInputs);
        }
    }

    // the output position should not change since there are no corVars
    // coming from below.
    return register(rel, newRel, identityMap(rel.getRowType().getFieldCount()), ImmutableSortedMap.of());
}
 

/** Fallback if none of the other {@code decorrelateRel} methods match. */
public Frame decorrelateRel(RelNode rel) {
  RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs());

  if (rel.getInputs().size() > 0) {
    List<RelNode> oldInputs = rel.getInputs();
    List<RelNode> newInputs = new ArrayList<>();
    for (int i = 0; i < oldInputs.size(); ++i) {
      final Frame frame = getInvoke(oldInputs.get(i), rel);
      if (frame == null || !frame.corDefOutputs.isEmpty()) {
        // if input is not rewritten, or if it produces correlated
        // variables, terminate rewrite
        return null;
      }
      newInputs.add(frame.r);
      newRel.replaceInput(i, frame.r);
    }

    if (!Util.equalShallow(oldInputs, newInputs)) {
      newRel = rel.copy(rel.getTraitSet(), newInputs);
    }
  }

  // the output position should not change since there are no corVars
  // coming from below.
  return register(rel, newRel, identityMap(rel.getRowType().getFieldCount()),
      ImmutableSortedMap.of());
}
 

/** Fallback if none of the other {@code decorrelateRel} methods match. */
public Frame decorrelateRel(RelNode rel) {
  RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs());

  if (rel.getInputs().size() > 0) {
    List<RelNode> oldInputs = rel.getInputs();
    List<RelNode> newInputs = new ArrayList<>();
    for (int i = 0; i < oldInputs.size(); ++i) {
      final Frame frame = getInvoke(oldInputs.get(i), rel);
      if (frame == null || !frame.corDefOutputs.isEmpty()) {
        // if input is not rewritten, or if it produces correlated
        // variables, terminate rewrite
        return null;
      }
      newInputs.add(frame.r);
      newRel.replaceInput(i, frame.r);
    }

    if (!Util.equalShallow(oldInputs, newInputs)) {
      newRel = rel.copy(rel.getTraitSet(), newInputs);
    }
  }

  // the output position should not change since there are no corVars
  // coming from below.
  return register(rel, newRel, identityMap(rel.getRowType().getFieldCount()),
      ImmutableSortedMap.of());
}
 

private void contractVertices(
    HepRelVertex preservedVertex,
    HepRelVertex discardedVertex,
    List<HepRelVertex> parents) {
  if (preservedVertex == discardedVertex) {
    // Nop.
    return;
  }

  RelNode rel = preservedVertex.getCurrentRel();
  updateVertex(preservedVertex, rel);

  // Update specified parents of discardedVertex.
  for (HepRelVertex parent : parents) {
    RelNode parentRel = parent.getCurrentRel();
    List<RelNode> inputs = parentRel.getInputs();
    for (int i = 0; i < inputs.size(); ++i) {
      RelNode child = inputs.get(i);
      if (child != discardedVertex) {
        continue;
      }
      parentRel.replaceInput(i, preservedVertex);
    }
    graph.removeEdge(parent, discardedVertex);
    graph.addEdge(parent, preservedVertex);
    updateVertex(parent, parentRel);
  }

  // NOTE:  we don't actually do graph.removeVertex(discardedVertex),
  // because it might still be reachable from preservedVertex.
  // Leave that job for garbage collection.

  if (discardedVertex == root) {
    root = preservedVertex;
  }
}
 

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 fixSharedOlapTableScanAt(RelNode parent, int ordinalInParent) {
    OLAPTableScan copy = copyTableScanIfNeeded(parent.getInputs().get(ordinalInParent));
    if (copy != null)
        parent.replaceInput(ordinalInParent, copy);
}
 

public void fixSharedOlapTableScanAt(RelNode parent, int ordinalInParent) {
    OLAPTableScan copy = copyTableScanIfNeeded(parent.getInputs().get(ordinalInParent));
    if (copy != null)
        parent.replaceInput(ordinalInParent, copy);
}