import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
public Result visitCalc(Calc e) {
  Result x = visitChild(0, e.getInput());
  final RexProgram program = e.getProgram();
  Builder builder =
      program.getCondition() != null
          ? x.builder(e, Clause.WHERE)
          : x.builder(e);
  if (!isStar(program)) {
    final List<SqlNode> selectList = new ArrayList<>();
    for (RexLocalRef ref : program.getProjectList()) {
      SqlNode sqlExpr = builder.context.toSql(program, ref);
      addSelect(selectList, sqlExpr, e.getRowType());
    }
    builder.setSelect(new SqlNodeList(selectList, POS));
  }

  if (program.getCondition() != null) {
    builder.setWhere(
        builder.context.toSql(program, program.getCondition()));
  }
  return builder.result();
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
/**
 * Constructs a CalcRelSplitter.
 *
 * @param calc     Calc to split
 * @param relTypes Array of rel types, e.g. {Java, Fennel}. Must be
 *                 distinct.
 */
CalcRelSplitter(Calc calc, RelBuilder relBuilder, RelType[] relTypes) {
  this.relBuilder = relBuilder;
  for (int i = 0; i < relTypes.length; i++) {
    assert relTypes[i] != null;
    for (int j = 0; j < i; j++) {
      assert relTypes[i] != relTypes[j]
          : "Rel types must be distinct";
    }
  }
  this.program = calc.getProgram();
  this.cluster = calc.getCluster();
  this.traits = calc.getTraitSet();
  this.typeFactory = calc.getCluster().getTypeFactory();
  this.child = calc.getInput();
  this.relTypes = relTypes;
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
/** @see #dispatch */
public Result visit(Calc e) {
  Result x = visitChild(0, e.getInput());
  parseCorrelTable(e, x);
  final RexProgram program = e.getProgram();
  Builder builder =
      program.getCondition() != null
          ? x.builder(e, Clause.WHERE)
          : x.builder(e);
  if (!isStar(program)) {
    final List<SqlNode> selectList = new ArrayList<>();
    for (RexLocalRef ref : program.getProjectList()) {
      SqlNode sqlExpr = builder.context.toSql(program, ref);
      addSelect(selectList, sqlExpr, e.getRowType());
    }
    builder.setSelect(new SqlNodeList(selectList, POS));
  }

  if (program.getCondition() != null) {
    builder.setWhere(
        builder.context.toSql(program, program.getCondition()));
  }
  return builder.result();
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
public final T traverse(RelNode n) throws Exception {
  List<T> inputStreams = new ArrayList<>();
  for (RelNode input : n.getInputs()) {
    inputStreams.add(traverse(input));
  }

  if (n instanceof Aggregate) {
    return visitAggregate((Aggregate) n, inputStreams);
  } else if (n instanceof Calc) {
    return visitCalc((Calc) n, inputStreams);
  } else if (n instanceof Collect) {
    return visitCollect((Collect) n, inputStreams);
  } else if (n instanceof Correlate) {
    return visitCorrelate((Correlate) n, inputStreams);
  } else if (n instanceof Delta) {
    return visitDelta((Delta) n, inputStreams);
  } else if (n instanceof Exchange) {
    return visitExchange((Exchange) n, inputStreams);
  } else if (n instanceof Project) {
    return visitProject((Project) n, inputStreams);
  } else if (n instanceof Filter) {
    return visitFilter((Filter) n, inputStreams);
  } else if (n instanceof Sample) {
    return visitSample((Sample) n, inputStreams);
  } else if (n instanceof Sort) {
    return visitSort((Sort) n, inputStreams);
  } else if (n instanceof TableModify) {
    return visitTableModify((TableModify) n, inputStreams);
  } else if (n instanceof TableScan) {
    return visitTableScan((TableScan) n, inputStreams);
  } else if (n instanceof Uncollect) {
    return visitUncollect((Uncollect) n, inputStreams);
  } else if (n instanceof Window) {
    return visitWindow((Window) n, inputStreams);
  } else if (n instanceof Join) {
    return visitJoin((Join) n, inputStreams);
  } else {
    return defaultValue(n, inputStreams);
  }
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
public Result visitChild(int i, RelNode e) {
  if (e instanceof Union) {
    return visitUnion((Union) e);
  } else if (e instanceof Join) {
    return visitJoin((Join) e);
  } else if (e instanceof Filter) {
    return visitFilter((Filter) e);
  } else if (e instanceof Project) {
    return visitProject((Project) e);
  } else if (e instanceof Aggregate) {
    return visitAggregate((Aggregate) e);
  } else if (e instanceof TableScan) {
    return visitTableScan((TableScan) e);
  } else if (e instanceof Intersect) {
    return visitIntersect((Intersect) e);
  } else if (e instanceof Minus) {
    return visitMinus((Minus) e);
  } else if (e instanceof Calc) {
    return visitCalc((Calc) e);
  } else if (e instanceof Sort) {
    return visitSort((Sort) e);
  } else if (e instanceof TableModify) {
    return visitTableModify((TableModify) e);
  } else if (e instanceof Limit) {
    return visitLimit((Limit) e);
  } else {
    throw new AssertionError("Need to Implement for " + e.getClass().getName()); // TODO:
  }
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
@Override
public Double getRowCount(Calc rel, RelMetadataQuery mq) {
    if (shouldIntercept(rel))
        return 1E10;

    return super.getRowCount(rel, mq);
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
/**
 * Creates a CalcMergeRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public CalcMergeRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(
          Calc.class,
          operand(Calc.class, any())),
      relBuilderFactory, null);
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
@Override public void onMatch(RelOptRuleCall call) {
  final Calc calc = call.rel(0);
  final Pair<ImmutableList<RexNode>, ImmutableList<RexNode>> projectFilter =
      calc.getProgram().split();
  final RelBuilder relBuilder = call.builder();
  relBuilder.push(calc.getInput());
  relBuilder.filter(projectFilter.right);
  relBuilder.project(projectFilter.left, calc.getRowType().getFieldNames());
  call.transformTo(relBuilder.build());
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
public T visitCalc(Calc calc, List<T> inputStreams) throws Exception {
  return defaultValue(calc, inputStreams);
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
public void onMatch(RelOptRuleCall call) {
  final Join joinRel = call.rel(0);
  final RelNode otherNode;
  final Calc calc;

  final RelNode leftJoinChild;
  final RelNode rightJoinChild;

  if (call.rel(1) instanceof Calc) {
    otherNode = call.rel(2);
    calc = call.rel(1);
    rightJoinChild = otherNode;
    leftJoinChild = calc.getInput();
  } else {
    otherNode = call.rel(1);
    calc = call.rel(2);
    rightJoinChild = calc.getInput();
    leftJoinChild = otherNode;
  }
  /**
   * Currently not supporting calc which doesnot
   * project star (all the columns of input)
   * or has aggregates.
   */
  if (!isStar(calc.getProgram())
      || calc.getProgram().containsAggs()) {
    return;
  }

  final List<RelDataTypeField> origFields =
      calc.getRowType().getFieldList();
  final int[] adjustments = new int[calc.getProgram().getExprCount()];
  if (rightJoinChild == calc.getInput()) {
    int offset = leftJoinChild.getRowType().getFieldList().size();
    for (int i = 0; i < origFields.size(); i++) {
      adjustments[i] = offset;
    }
  }
  Join newJoinRel =
      joinRel.copy(joinRel.getTraitSet(), joinRel.getCondition(),
          leftJoinChild, rightJoinChild, joinRel.getJoinType(),
          joinRel.isSemiJoinDone());

  RexProgramBuilder topProgramBuilder =
      new RexProgramBuilder(
          joinRel.getRowType(),
          joinRel.getCluster().getRexBuilder());
  topProgramBuilder.addIdentity();
  final RelOptUtil.RexInputConverter rexInputConverter =
      new RelOptUtil.RexInputConverter(calc.getCluster().getRexBuilder(),
          origFields,
          joinRel.getRowType().getFieldList(),
          adjustments);
  if (calc.getProgram().getCondition() != null) {
    RexNode cond =
        calc.getProgram().expandLocalRef(calc.getProgram().getCondition());
    final RexLocalRef rexLocalRef =
        topProgramBuilder.addExpr(cond.accept(rexInputConverter));
    topProgramBuilder.addCondition(rexLocalRef);
  }
  Calc newCalcRel =
      calc.copy(calc.getTraitSet(), newJoinRel, topProgramBuilder.getProgram());

  call.transformTo(newCalcRel);
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
public Multimap<Class<? extends RelNode>, RelNode> getNodeTypes(Calc rel,
    RelMetadataQuery mq) {
  return getNodeTypes(rel, Calc.class, mq);
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
public ImmutableList<RelCollation> collations(Calc calc,
    RelMetadataQuery mq) {
  return ImmutableList.copyOf(calc(mq, calc.getInput(), calc.getProgram()));
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
public Double getRowCount(Calc rel, RelMetadataQuery mq) {
  return RelMdUtil.estimateFilteredRows(rel.getInput(), rel.getProgram(), mq);
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
@Deprecated // to be removed before 2.0
public CalcReduceExpressionsRule(Class<? extends Calc> calcClass,
    RelBuilderFactory relBuilderFactory) {
  this(calcClass, true, relBuilderFactory);
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
/**
 * Creates a CalcToWindowRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public CalcToWindowRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(Calc.class, null, PREDICATE, any()),
      relBuilderFactory, "ProjectToWindowRule");
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
WindowedAggRelSplitter(Calc calc, RelBuilder relBuilder) {
  super(calc, relBuilder, REL_TYPES);
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
/**
 * Drills schema flexibility requires us to override the default behavior of calcite
 * to produce an EmptyRel in the case of a constant false filter. We need to propagate
 * schema at runtime, so we cannot just produce a simple operator at planning time to
 * expose the planning time known schema. Instead we have to insert a limit 0.
 */
@Override
protected RelNode createEmptyRelOrEquivalent(Calc calc) {
  return createEmptyEmptyRelHelper(calc);
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
/**
 * For static schema systems, a filter that is always false or null can be
 * replaced by a values operator that produces no rows, as the schema
 * information can just be taken from the input Rel. In dynamic schema
 * environments, the filter might have an unknown input type, in these cases
 * they must define a system specific alternative to a Values operator, such
 * as inserting a limit 0 instead of a filter on top of the original input.
 *
 * <p>The default implementation of this method is to call
 * {@link RelBuilder#empty}, which for the static schema will be optimized
 * to an empty
 * {@link org.apache.calcite.rel.core.Values}.
 *
 * @param input rel to replace, assumes caller has already determined
 *              equivalence to Values operation for 0 records or a
 *              false filter.
 * @return equivalent but less expensive replacement rel
 */
protected RelNode createEmptyRelOrEquivalent(RelOptRuleCall call, Calc input) {
  return call.builder().push(input).empty().build();
}
 

import org.apache.calcite.rel.core.Calc; //导入依赖的package包/类
/**
 * Creates a CalcSplitRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public CalcSplitRule(RelBuilderFactory relBuilderFactory) {
  super(operand(Calc.class, any()), relBuilderFactory, null);
}