Java SqlExplainLevel类代码示例

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
/**
 * Generate readable text and json plans and set them in <code>planHolder</code>
 * @param rel
 * @param explainlevel explain plan level.
 * @param observer
 */
public static String setPlansWithIds(final Prel rel, final SqlExplainLevel explainlevel, final AttemptObserver observer, final long millisTaken) {
  if (rel == null) {
    return null;
  }

  Map<Prel, OpId> relIdMap = getIdMap(rel);
  final StringWriter sw = new StringWriter();
  final RelWriter textPlanWriter = new NumberingRelWriter(relIdMap, new PrintWriter(sw), explainlevel);
  rel.explain(textPlanWriter);

  final String textPlan = sw.toString();
  observer.planText(sw.toString(), millisTaken);
  final RelJsonWriter jsonPlanWriter = new RelJsonWriter(getIdMap(rel), explainlevel);
  rel.explain(jsonPlanWriter);
  observer.planJsonPlan(jsonPlanWriter.asString());
  return textPlan;
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
/**
 * Walks over a tree of relational expressions, replacing each
 * {@link RelNode} with a 'slimmed down' relational expression that projects
 * only the fields required by its consumer.
 *
 * <p>This may make things easier for the optimizer, by removing crud that
 * would expand the search space, but is difficult for the optimizer itself
 * to do it, because optimizer rules must preserve the number and type of
 * fields. Hence, this transform that operates on the entire tree, similar
 * to the {@link RelStructuredTypeFlattener type-flattening transform}.
 *
 * <p>Currently this functionality is disabled in farrago/luciddb; the
 * default implementation of this method does nothing.
 *
 * @param ordered Whether the relational expression must produce results in
 * a particular order (typically because it has an ORDER BY at top level)
 * @param rootRel Relational expression that is at the root of the tree
 * @return Trimmed relational expression
 */
public RelNode trimUnusedFields(boolean ordered, RelNode rootRel) {
	// Trim fields that are not used by their consumer.
	if (isTrimUnusedFields()) {
		final RelFieldTrimmer trimmer = newFieldTrimmer();
		final List<RelCollation> collations =
			rootRel.getTraitSet().getTraits(RelCollationTraitDef.INSTANCE);
		rootRel = trimmer.trim(rootRel);
		if (!ordered
			&& collations != null
			&& !collations.isEmpty()
			&& !collations.equals(ImmutableList.of(RelCollations.EMPTY))) {
			final RelTraitSet traitSet = rootRel.getTraitSet()
				.replace(RelCollationTraitDef.INSTANCE, collations);
			rootRel = rootRel.copy(traitSet, rootRel.getInputs());
		}
		if (SQL2REL_LOGGER.isDebugEnabled()) {
			SQL2REL_LOGGER.debug(
				RelOptUtil.dumpPlan("Plan after trimming unused fields", rootRel,
					SqlExplainFormat.TEXT, SqlExplainLevel.EXPPLAN_ATTRIBUTES));
		}
	}
	return rootRel;
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
/**
 * Decorrelates a query.
 * <p>
 * <p>This is the main entry point to {@code FlinkRelDecorrelator}.
 *
 * @param rootRel Root node of the query
 * @return Equivalent query with all
 * {@link LogicalCorrelate} instances removed
 */
public static RelNode decorrelateQuery(RelNode rootRel) {
	final CorelMap corelMap = new CorelMapBuilder().build(rootRel);
	if (!corelMap.hasCorrelation()) {
		return rootRel;
	}

	final RelOptCluster cluster = rootRel.getCluster();
	final FlinkRelDecorrelator decorrelator = new FlinkRelDecorrelator(cluster, corelMap, cluster.getPlanner().getContext());

	RelNode newRootRel = decorrelator.removeCorrelationViaRule(rootRel);

	if (SQL2REL_LOGGER.isDebugEnabled()) {
		SQL2REL_LOGGER.debug(RelOptUtil.dumpPlan("Plan after removing Correlator", newRootRel, false, SqlExplainLevel.EXPPLAN_ATTRIBUTES));
	}

	if (!decorrelator.cm.mapCorVarToCorRel.isEmpty()) {
		newRootRel = decorrelator.decorrelate(newRootRel);
	}

	return newRootRel;
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
/**
 * Walks over a tree of relational expressions, replacing each
 * {@link RelNode} with a 'slimmed down' relational expression that projects
 * only the fields required by its consumer.
 *
 * <p>This may make things easier for the optimizer, by removing crud that
 * would expand the search space, but is difficult for the optimizer itself
 * to do it, because optimizer rules must preserve the number and type of
 * fields. Hence, this transform that operates on the entire tree, similar
 * to the {@link RelStructuredTypeFlattener type-flattening transform}.
 *
 * <p>Currently this functionality is disabled in farrago/luciddb; the
 * default implementation of this method does nothing.
 *
 * @param ordered Whether the relational expression must produce results in
 * a particular order (typically because it has an ORDER BY at top level)
 * @param rootRel Relational expression that is at the root of the tree
 * @return Trimmed relational expression
 */
public RelNode trimUnusedFields(boolean ordered, RelNode rootRel) {
  // Trim fields that are not used by their consumer.
  if (isTrimUnusedFields()) {
    final RelFieldTrimmer trimmer = newFieldTrimmer();
    final List<RelCollation> collations =
        rootRel.getTraitSet().getTraits(RelCollationTraitDef.INSTANCE);
    rootRel = trimmer.trim(rootRel);
    if (!ordered
        && collations != null
        && !collations.isEmpty()
        && !collations.equals(ImmutableList.of(RelCollations.EMPTY))) {
      final RelTraitSet traitSet = rootRel.getTraitSet()
          .replace(RelCollationTraitDef.INSTANCE, collations);
      rootRel = rootRel.copy(traitSet, rootRel.getInputs());
    }
    if (SQL2REL_LOGGER.isDebugEnabled()) {
      SQL2REL_LOGGER.debug(
          RelOptUtil.dumpPlan("Plan after trimming unused fields", rootRel,
              SqlExplainFormat.TEXT, SqlExplainLevel.EXPPLAN_ATTRIBUTES));
    }
  }
  return rootRel;
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
/** Decorrelates a query.
 *
 * <p>This is the main entry point to {@code RelDecorrelator}.
 *
 * @param rootRel Root node of the query
 *
 * @return Equivalent query with all
 * {@link org.apache.calcite.rel.logical.LogicalCorrelate} instances removed
 */
public static RelNode decorrelateQuery(RelNode rootRel) {
  final CorelMap corelMap = new CorelMapBuilder().build(rootRel);
  if (!corelMap.hasCorrelation()) {
    return rootRel;
  }

  final RelOptCluster cluster = rootRel.getCluster();
  final RelDecorrelator decorrelator =
      new RelDecorrelator(cluster, corelMap,
          cluster.getPlanner().getContext());

  RelNode newRootRel = decorrelator.removeCorrelationViaRule(rootRel);

  if (SQL2REL_LOGGER.isDebugEnabled()) {
    SQL2REL_LOGGER.debug(
        RelOptUtil.dumpPlan("Plan after removing Correlator", newRootRel,
            SqlExplainFormat.TEXT, SqlExplainLevel.EXPPLAN_ATTRIBUTES));
  }

  if (!decorrelator.cm.mapCorToCorRel.isEmpty()) {
    newRootRel = decorrelator.decorrelate(newRootRel);
  }

  return newRootRel;
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
/**
 * Trims unused fields from a relational expression.
 *
 * <p>We presume that all fields of the relational expression are wanted by
 * its consumer, so only trim fields that are not used within the tree.
 *
 * @param root Root node of relational expression
 * @return Trimmed relational expression
 */
public RelNode trim(RelNode root) {
  final int fieldCount = root.getRowType().getFieldCount();
  final ImmutableBitSet fieldsUsed = ImmutableBitSet.range(fieldCount);
  final Set<RelDataTypeField> extraFields = Collections.emptySet();
  final TrimResult trimResult =
      dispatchTrimFields(root, fieldsUsed, extraFields);
  if (!trimResult.right.isIdentity()) {
    throw new IllegalArgumentException();
  }
  if (SqlToRelConverter.SQL2REL_LOGGER.isDebugEnabled()) {
    SqlToRelConverter.SQL2REL_LOGGER.debug(
        RelOptUtil.dumpPlan("Plan after trimming unused fields",
            trimResult.left, SqlExplainFormat.TEXT,
            SqlExplainLevel.EXPPLAN_ATTRIBUTES));
  }
  return trimResult.left;
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
public void setRoot(RelNode rel) {
  // We're registered all the rules, and therefore RelNode classes,
  // we're interested in, and have not yet started calling metadata providers.
  // So now is a good time to tell the metadata layer what to expect.
  registerMetadataRels();

  this.root = registerImpl(rel, null);
  if (this.originalRoot == null) {
    this.originalRoot = rel;
  }
  this.originalRootString =
      RelOptUtil.toString(root, SqlExplainLevel.ALL_ATTRIBUTES);

  // Making a node the root changes its importance.
  this.ruleQueue.recompute(this.root);
  ensureRootConverters();
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
/**
 * Converts a relational expression to a form where
 * {@link org.apache.calcite.rel.logical.LogicalJoin}s are
 * as close to leaves as possible.
 */
public static RelNode toLeafJoinForm(RelNode rel) {
  final Program program = Programs.hep(
      ImmutableList.of(
          JoinProjectTransposeRule.RIGHT_PROJECT,
          JoinProjectTransposeRule.LEFT_PROJECT,
          FilterJoinRule.FilterIntoJoinRule.FILTER_ON_JOIN,
          ProjectRemoveRule.INSTANCE,
          ProjectMergeRule.INSTANCE),
      false,
      DefaultRelMetadataProvider.INSTANCE);
  if (CalcitePrepareImpl.DEBUG) {
    System.out.println(
        RelOptUtil.dumpPlan("before", rel, SqlExplainFormat.TEXT,
            SqlExplainLevel.DIGEST_ATTRIBUTES));
  }
  final RelNode rel2 = program.run(null, rel, null,
      ImmutableList.<RelOptMaterialization>of(),
      ImmutableList.<RelOptLattice>of());
  if (CalcitePrepareImpl.DEBUG) {
    System.out.println(
        RelOptUtil.dumpPlan("after", rel2, SqlExplainFormat.TEXT,
            SqlExplainLevel.DIGEST_ATTRIBUTES));
  }
  return rel2;
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
@Test public void testExplainAsXml() {
  String sql = "select 1 + 2, 3 from (values (true))";
  final RelNode rel = tester.convertSqlToRel(sql).rel;
  StringWriter sw = new StringWriter();
  PrintWriter pw = new PrintWriter(sw);
  RelXmlWriter planWriter =
      new RelXmlWriter(pw, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
  rel.explain(planWriter);
  pw.flush();
  TestUtil.assertEqualsVerbose(
      "<RelNode type=\"LogicalProject\">\n"
          + "\t<Property name=\"EXPR$0\">\n"
          + "\t\t+(1, 2)\t</Property>\n"
          + "\t<Property name=\"EXPR$1\">\n"
          + "\t\t3\t</Property>\n"
          + "\t<Inputs>\n"
          + "\t\t<RelNode type=\"LogicalValues\">\n"
          + "\t\t\t<Property name=\"tuples\">\n"
          + "\t\t\t\t[{ true }]\t\t\t</Property>\n"
          + "\t\t\t<Inputs/>\n"
          + "\t\t</RelNode>\n"
          + "\t</Inputs>\n"
          + "</RelNode>\n",
      Util.toLinux(sw.toString()));
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
public RelWriter explainTerms(RelWriter pw) {
  return super.explainTerms(pw)
      .itemIf("type", this.rowType, pw.getDetailLevel() == SqlExplainLevel.DIGEST_ATTRIBUTES)
      .itemIf("type", this.rowType.getFieldList(), pw.nest())
      .itemIf("tuplesCount", rowCount, pw.getDetailLevel() != SqlExplainLevel.ALL_ATTRIBUTES)
      .itemIf("tuples", options.asNode(), pw.getDetailLevel() == SqlExplainLevel.ALL_ATTRIBUTES);
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
public static String printWithIds(final Prel rel, SqlExplainLevel explainlevel) {
    if (rel == null) {
      return null;
    }
    final StringWriter sw = new StringWriter();
    final RelWriter planWriter = new NumberingRelWriter(getIdMap(rel), new PrintWriter(sw), explainlevel);
    rel.explain(planWriter);
    return sw.toString();

}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
protected void log(final String name, final Prel node, final Logger logger) {
  String plan = PrelSequencer.printWithIds(node, SqlExplainLevel.ALL_ATTRIBUTES);
  if(textPlan != null){
    textPlan.value = plan;
  }

  if (logger.isDebugEnabled()) {
    logger.debug(name + " : \n" + plan);
  }
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
public LogicalExplain(RelNode node, SqlExplainLevel level, QueryContext context) {
  this.text = RelOptUtil.toString(node, level);
  DrillImplementor implementor = new DrillImplementor(new DrillParseContext(context.getPlannerSettings()), ResultMode.LOGICAL);
  implementor.go( (DrillRel) node);
  LogicalPlan plan = implementor.getPlan();
  this.json = plan.unparse(context.getConfig());
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
/**
 * This method will take a SQL string statement, get the LOGICAL plan in Optiq
 * RelNode format. Then check the physical plan against the list expected
 * substrs. Verify all the expected strings are contained in the physical plan
 * string.
 */
public static void testRelLogicalJoinOrder(String sql, String... expectedSubstrs) throws Exception {
  final String planStr = getDrillRelPlanInString(sql, SqlExplainLevel.EXPPLAN_ATTRIBUTES, Depth.LOGICAL);
  final String prefixJoinOrder = getLogicalPrefixJoinOrderFromPlan(planStr);
  System.out.println(" prefix Join order = \n" + prefixJoinOrder);
  for (final String substr : expectedSubstrs) {
    assertTrue(String.format("Expected string %s is not in the prefixJoinOrder %s!", substr, prefixJoinOrder),
        prefixJoinOrder.contains(substr));
  }
}
 

import org.apache.calcite.sql.SqlExplainLevel; //导入依赖的package包/类
/**
 * This method will take a SQL string statement, get the LOGICAL plan in Optiq
 * RelNode format. Then check the physical plan against the list expected
 * substrs. Verify all the expected strings are contained in the physical plan
 * string.
 */
public static void testRelPhysicalJoinOrder(String sql, String... expectedSubstrs) throws Exception {
  final String planStr = getDrillRelPlanInString(sql, SqlExplainLevel.EXPPLAN_ATTRIBUTES, Depth.PHYSICAL);
  final String prefixJoinOrder = getPhysicalPrefixJoinOrderFromPlan(planStr);
  System.out.println(" prefix Join order = \n" + prefixJoinOrder);
  for (final String substr : expectedSubstrs) {
    assertTrue(String.format("Expected string %s is not in the prefixJoinOrder %s!", substr, prefixJoinOrder),
        prefixJoinOrder.contains(substr));
  }
}