import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
@Override
public RelNode visit(LogicalValues values) {

  return new LogicalValues(
    cluster,
    copyOf(values.getTraitSet()),
    copyOf(values.getRowType()),
    copyOf(values.getTuples())
  );
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
@Override public RelNode convert(RelNode rel) {
  LogicalValues values = (LogicalValues) rel;
  return new SparkValues(
      values.getCluster(),
      values.getRowType(),
      values.getTuples(),
      values.getTraitSet().replace(getOutTrait()));
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
public void rewriteRel(LogicalValues rel) {
  // NOTE jvs 30-Apr-2006:  UDT instances require invocation
  // of a constructor method, which can't be represented
  // by the tuples stored in a LogicalValues, so we don't have
  // to worry about them here.
  rewriteGeneric(rel);
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
@Override
public RelNode doApply(LogicalTableModify tableModify, JournalledJdbcTable journalTable,
		JdbcRelBuilderFactory relBuilderFactory) {

	JdbcRelBuilder relBuilder = relBuilderFactory.create(
			tableModify.getCluster(),
			tableModify.getTable().getRelOptSchema()
	);

	RelNode input = tableModify.getInput();
	if (input instanceof LogicalValues) {

		// TODO: do we need to do anything here?
		relBuilder.push(input);

	}
	else if (input instanceof LogicalProject) {

		LogicalProject project = (LogicalProject) input;
		List<RexNode> desiredFields = new ArrayList<>();
		List<String> desiredNames = new ArrayList<>();
		for (Pair<RexNode, String> field : project.getNamedProjects()) {
			if (field.getKey() instanceof RexInputRef) {
				desiredFields.add(field.getKey());
				desiredNames.add(field.getValue());
			}
		}

		relBuilder.push(project.getInput());
		relBuilder.project(desiredFields, desiredNames);

	}
	else {
		throw new IllegalStateException("Unknown Calcite INSERT structure");
	}

	relBuilder.insertCopying(
			tableModify,
			journalTable.getJournalTable()
	);

	return relBuilder.build();

}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
private DrillValuesRule() {
  super(RelOptHelper.any(LogicalValues.class, Convention.NONE), "DrillValuesRule");
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {
  final LogicalValues values = (LogicalValues) call.rel(0);
  final RelTraitSet traits = values.getTraitSet().plus(DrillRel.DRILL_LOGICAL);
  call.transformTo(new DrillValuesRel(values.getCluster(), values.getRowType(), values.getTuples(), traits));
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
@Override
public RelNode visit(LogicalValues values) {
  values.getCluster().setMetadataProvider(metadataProvider);
  return super.visit(values);
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
@Override
public RelNode visit(LogicalValues values) {
  return visit((RelNode) values);
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
private ValuesRule() {
  super(RelOptHelper.any(LogicalValues.class, Convention.NONE), "ValuesRule");
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {
  final LogicalValues values = (LogicalValues) call.rel(0);
  final RelTraitSet traits = values.getTraitSet().plus(Rel.LOGICAL);
  call.transformTo(new ValuesRel(values.getCluster(), values.getRowType(), values.getTuples(), traits));
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
private BeamValuesRule() {
  super(LogicalValues.class, Convention.NONE,
      BeamLogicalConvention.INSTANCE, "BeamValuesRule");
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
/**
 * Converts a values clause (as in "INSERT INTO T(x,y) VALUES (1,2)") into a
 * relational expression.
 *
 * @param bb            Blackboard
 * @param values        Call to SQL VALUES operator
 * @param targetRowType Target row type
 */
private void convertValuesImpl(
	Blackboard bb,
	SqlCall values,
	RelDataType targetRowType) {
	// Attempt direct conversion to LogicalValues; if that fails, deal with
	// fancy stuff like sub-queries below.
	RelNode valuesRel =
		convertRowValues(
			bb,
			values,
			values.getOperandList(),
			true,
			targetRowType);
	if (valuesRel != null) {
		bb.setRoot(valuesRel, true);
		return;
	}

	final List<RelNode> unionRels = new ArrayList<>();
	for (SqlNode rowConstructor1 : values.getOperandList()) {
		SqlCall rowConstructor = (SqlCall) rowConstructor1;
		Blackboard tmpBb = createBlackboard(bb.scope, null, false);
		replaceSubQueries(tmpBb, rowConstructor,
			RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
		final List<Pair<RexNode, String>> exps = new ArrayList<>();
		for (Ord<SqlNode> operand : Ord.zip(rowConstructor.getOperandList())) {
			exps.add(
				Pair.of(
					tmpBb.convertExpression(operand.e),
					validator.deriveAlias(operand.e, operand.i)));
		}
		RelNode in =
			(null == tmpBb.root)
				? LogicalValues.createOneRow(cluster)
				: tmpBb.root;
		unionRels.add(
			RelOptUtil.createProject(
				in,
				Pair.left(exps),
				Pair.right(exps),
				true));
	}

	if (unionRels.size() == 0) {
		throw new AssertionError("empty values clause");
	} else if (unionRels.size() == 1) {
		bb.setRoot(
			unionRels.get(0),
			true);
	} else {
		bb.setRoot(
			LogicalUnion.create(unionRels, true),
			true);
	}

	// REVIEW jvs 22-Jan-2004:  should I add
	// mapScopeToLux.put(validator.getScope(values),bb.root);
	// ?
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
private JdbcValuesRule(JdbcConvention out) {
    super(LogicalValues.class, Convention.NONE, out, "JdbcValuesRule");
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
@Override
public RelNode convert(RelNode rel) {
    LogicalValues values = (LogicalValues) rel;
    return new JdbcValues(values.getCluster(), values.getRowType(),
            values.getTuples(), values.getTraitSet().replace(getOut()));
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
/**
 * Converts a values clause (as in "INSERT INTO T(x,y) VALUES (1,2)") into a
 * relational expression.
 *
 * @param bb            Blackboard
 * @param values        Call to SQL VALUES operator
 * @param targetRowType Target row type
 */
private void convertValuesImpl(
    Blackboard bb,
    SqlCall values,
    RelDataType targetRowType) {
  // Attempt direct conversion to LogicalValues; if that fails, deal with
  // fancy stuff like sub-queries below.
  RelNode valuesRel =
      convertRowValues(
          bb,
          values,
          values.getOperandList(),
          true,
          targetRowType);
  if (valuesRel != null) {
    bb.setRoot(valuesRel, true);
    return;
  }

  final List<RelNode> unionRels = new ArrayList<>();
  for (SqlNode rowConstructor1 : values.getOperandList()) {
    SqlCall rowConstructor = (SqlCall) rowConstructor1;
    Blackboard tmpBb = createBlackboard(bb.scope, null, false);
    replaceSubQueries(tmpBb, rowConstructor,
        RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
    final List<Pair<RexNode, String>> exps = new ArrayList<>();
    for (Ord<SqlNode> operand : Ord.zip(rowConstructor.getOperandList())) {
      exps.add(
          Pair.of(
              tmpBb.convertExpression(operand.e),
              validator.deriveAlias(operand.e, operand.i)));
    }
    RelNode in =
        (null == tmpBb.root)
            ? LogicalValues.createOneRow(cluster)
            : tmpBb.root;
    unionRels.add(
        RelOptUtil.createProject(
            in,
            Pair.left(exps),
            Pair.right(exps),
            true));
  }

  if (unionRels.size() == 0) {
    throw new AssertionError("empty values clause");
  } else if (unionRels.size() == 1) {
    bb.setRoot(
        unionRels.get(0),
        true);
  } else {
    bb.setRoot(
        LogicalUnion.create(unionRels, true),
        true);
  }

  // REVIEW jvs 22-Jan-2004:  should I add
  // mapScopeToLux.put(validator.getScope(values),bb.root);
  // ?
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
private SparkValuesRule() {
  super(LogicalValues.class, Convention.NONE, SparkRel.CONVENTION,
      "SparkValuesRule");
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
@Override public RelNode visit(LogicalValues values) {
  return visit((RelNode) values);
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
public void onMatch(RelOptRuleCall call) {
  LogicalFilter filter = call.rel(0);
  LogicalValues values = call.rel(1);
  apply(call, null, filter, values);
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
public RelNode visit(LogicalValues values) {
  return values;
}
 

import org.apache.calcite.rel.logical.LogicalValues; //导入依赖的package包/类
public RelNode createValues(RelOptCluster cluster, RelDataType rowType,
    List<ImmutableList<RexLiteral>> tuples) {
  return LogicalValues.create(cluster, rowType,
      ImmutableList.copyOf(tuples));
}