org.apache.calcite.rel.logical.LogicalTableModify Java Examples

public PreparedResultImpl(
    RelDataType rowType,
    RelDataType parameterRowType,
    List<List<String>> fieldOrigins,
    List<RelCollation> collations,
    RelNode rootRel,
    LogicalTableModify.Operation tableModOp,
    boolean isDml) {
  this.rowType = Objects.requireNonNull(rowType);
  this.parameterRowType = Objects.requireNonNull(parameterRowType);
  this.fieldOrigins = Objects.requireNonNull(fieldOrigins);
  this.collations = ImmutableList.copyOf(collations);
  this.rootRel = Objects.requireNonNull(rootRel);
  this.tableModOp = tableModOp;
  this.isDml = isDml;
}
 

@Override
public RelNode convert(RelNode rel) {
    final LogicalTableModify modify =
        (LogicalTableModify) rel;
    final ModifiableTable modifiableTable =
        modify.getTable().unwrap(ModifiableTable.class);
    if (modifiableTable == null) {
        return null;
    }
    final RelTraitSet traitSet =
        modify.getTraitSet().replace(EnumerableConvention.INSTANCE);
    return new EnumerableTableModifyExtension(
        modify.getCluster(), traitSet,
        modify.getTable(),
        modify.getCatalogReader(),
        convert(modify.getInput(), traitSet),
        modify.getOperation(),
        modify.getUpdateColumnList(),
        modify.getSourceExpressionList(),
        modify.isFlattened());
}
 

@Override public RelNode convert(RelNode rel) {
  final LogicalTableModify modify =
      (LogicalTableModify) rel;
  final ModifiableTable modifiableTable =
      modify.getTable().unwrap(ModifiableTable.class);
  if (modifiableTable == null) {
    return null;
  }
  final RelTraitSet traitSet =
      modify.getTraitSet().replace(EnumerableConvention.INSTANCE);
  return new EnumerableTableModify(
      modify.getCluster(), traitSet,
      modify.getTable(),
      modify.getCatalogReader(),
      convert(modify.getInput(), traitSet),
      modify.getOperation(),
      modify.getUpdateColumnList(),
      modify.getSourceExpressionList(),
      modify.isFlattened());
}
 

protected LogicalTableModify.Operation mapTableModOp(
    boolean isDml, SqlKind sqlKind) {
  if (!isDml) {
    return null;
  }
  switch (sqlKind) {
  case INSERT:
    return LogicalTableModify.Operation.INSERT;
  case DELETE:
    return LogicalTableModify.Operation.DELETE;
  case MERGE:
    return LogicalTableModify.Operation.MERGE;
  case UPDATE:
    return LogicalTableModify.Operation.UPDATE;
  default:
    return null;
  }
}
 

public JdbcRelBuilder insertCopying(
		LogicalTableModify original,
		Table table
) {
	List<String> name = JdbcTableUtils.getQualifiedName(original.getTable(), table);

	push(new LogicalTableModify(
			cluster,
			original.getTraitSet(),
			relOptSchema.getTableForMember(name),
			original.getCatalogReader(),
			peek(),
			TableModify.Operation.INSERT,
			null,
			null,
			original.isFlattened()
	));
	return this;
}
 

@Test void testTableModifyInsert() {
  final FrameworkConfig config = RelBuilderTest.config().build();
  final RelBuilder builder = RelBuilder.create(config);
  RelNode project = builder
      .scan("EMP")
      .project(builder.fields(), ImmutableList.of(), true)
      .build();
  LogicalTableModify modify = LogicalTableModify.create(
      project.getInput(0).getTable(),
      (Prepare.CatalogReader) project.getInput(0).getTable().getRelOptSchema(),
      project,
      TableModify.Operation.INSERT,
      null,
      null,
      false);
  String relJson = RelOptUtil.dumpPlan("", modify,
      SqlExplainFormat.JSON, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
  String s = deserializeAndDumpToTextFormat(getSchema(modify), relJson);
  final String expected = ""
      + "LogicalTableModify(table=[[scott, EMP]], operation=[INSERT], flattened=[false])\n"
      + "  LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], "
      + "COMM=[$6], DEPTNO=[$7])\n"
      + "    LogicalTableScan(table=[[scott, EMP]])\n";
  assertThat(s, isLinux(expected));
}
 

@Override
public RelNode apply(RelNode originalRel, JdbcRelBuilderFactory relBuilderFactory) {

	if (!(originalRel instanceof LogicalTableModify)) {
		return null;
	}

	LogicalTableModify tableModify = (LogicalTableModify) originalRel;

	if (tableModify.getOperation() != operation) {
		return null;
	}

	Table baseTable = JdbcTableUtils.getJdbcTable(tableModify);
	if (!(baseTable instanceof JournalledJdbcTable)) {
		// Not a journal table; nothing to do
		return null;
	}
	JournalledJdbcTable journalTable = (JournalledJdbcTable) baseTable;

	return doApply(tableModify, journalTable, relBuilderFactory);
}
 

@Test void testRelShuttleForLogicalTableModify() {
  final String sql = "insert into emp select * from emp";
  final LogicalTableModify rel = (LogicalTableModify) tester.convertSqlToRel(sql).rel;
  final List<RelNode> rels = new ArrayList<>();
  final RelShuttleImpl visitor = new RelShuttleImpl() {
    @Override public RelNode visit(LogicalTableModify modify) {
      RelNode visitedRel = super.visit(modify);
      rels.add(visitedRel);
      return visitedRel;
    }
  };
  visitor.visit(rel);
  assertThat(rels.size(), is(1));
  assertThat(rels.get(0), isA(LogicalTableModify.class));
}
 

@Override public TableModify toModificationRel(RelOptCluster cluster,
    RelOptTable table, CatalogReader catalogReader, RelNode input,
    Operation operation, List<String> updateColumnList,
    List<RexNode> sourceExpressionList, boolean flattened) {
  jdbcSchema.convention.register(cluster.getPlanner());

  return new LogicalTableModify(cluster, cluster.traitSetOf(Convention.NONE),
      table, catalogReader, input, operation, updateColumnList,
      sourceExpressionList, flattened);
}
 

public void rewriteRel(LogicalTableModify rel) {
  LogicalTableModify newRel =
      LogicalTableModify.create(
          rel.getTable(),
          rel.getCatalogReader(),
          getNewForOldRel(rel.getInput()),
          rel.getOperation(),
          rel.getUpdateColumnList(),
          rel.getSourceExpressionList(),
          true);
  setNewForOldRel(rel, newRel);
}
 

@Override public TableModify toModificationRel(
    RelOptCluster cluster,
    RelOptTable table,
    Prepare.CatalogReader catalogReader,
    RelNode child,
    TableModify.Operation operation,
    List<String> updateColumnList,
    List<RexNode> sourceExpressionList,
    boolean flattened) {
  return LogicalTableModify.create(table, catalogReader, child, operation,
      updateColumnList, sourceExpressionList, flattened);
}
 

public TableModify toModificationRel(RelOptCluster cluster,
    RelOptTable table, Prepare.CatalogReader catalogReader, RelNode child,
    TableModify.Operation operation, List<String> updateColumnList,
    List<RexNode> sourceExpressionList, boolean flattened) {
  return LogicalTableModify.create(table, catalogReader, child, operation,
      updateColumnList, sourceExpressionList, flattened);
}
 

@Override public TableModify toModificationRel(
    RelOptCluster cluster,
    RelOptTable table,
    Prepare.CatalogReader catalogReader,
    RelNode child,
    TableModify.Operation operation,
    List<String> updateColumnList,
    List<RexNode> sourceExpressionList,
    boolean flattened) {
  return LogicalTableModify.create(table, catalogReader, child, operation,
      updateColumnList, sourceExpressionList, flattened);
}
 

/**
 * Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-3826">[CALCITE-3826]
 * UPDATE assigns wrong type to bind variables</a>.
 */
@Test void testDynamicParamTypesInUpdate() {
  RelNode rel = tester.convertSqlToRel("update emp set sal = ?, ename = ? where empno = ?").rel;
  LogicalTableModify modify = (LogicalTableModify) rel;
  List<RexNode> parameters = modify.getSourceExpressionList();
  assertThat(parameters.size(), is(2));
  assertThat(parameters.get(0).getType().getSqlTypeName(), is(SqlTypeName.INTEGER));
  assertThat(parameters.get(1).getType().getSqlTypeName(), is(SqlTypeName.VARCHAR));
}
 

@Test void testTableModifyUpdate() {
  final FrameworkConfig config = RelBuilderTest.config().build();
  final RelBuilder builder = RelBuilder.create(config);
  RelNode filter = builder
      .scan("EMP")
      .filter(
          builder.call(
              SqlStdOperatorTable.EQUALS,
              builder.field("JOB"),
              builder.literal("c")))
      .build();
  LogicalTableModify modify = LogicalTableModify.create(
      filter.getInput(0).getTable(),
      (Prepare.CatalogReader) filter.getInput(0).getTable().getRelOptSchema(),
      filter,
      TableModify.Operation.UPDATE,
      ImmutableList.of("ENAME"),
      ImmutableList.of(builder.literal("a")),
      false);
  String relJson = RelOptUtil.dumpPlan("", modify,
      SqlExplainFormat.JSON, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
  String s = deserializeAndDumpToTextFormat(getSchema(modify), relJson);
  final String expected = ""
      + "LogicalTableModify(table=[[scott, EMP]], operation=[UPDATE], updateColumnList=[[ENAME]],"
      + " sourceExpressionList=[['a']], flattened=[false])\n"
      + "  LogicalFilter(condition=[=($2, 'c')])\n"
      + "    LogicalTableScan(table=[[scott, EMP]])\n";
  assertThat(s, isLinux(expected));
}
 

@Test void testTableModifyDelete() {
  final FrameworkConfig config = RelBuilderTest.config().build();
  final RelBuilder builder = RelBuilder.create(config);
  RelNode filter = builder
      .scan("EMP")
      .filter(
          builder.call(
              SqlStdOperatorTable.EQUALS,
              builder.field("JOB"),
              builder.literal("c")))
      .build();
  LogicalTableModify modify = LogicalTableModify.create(
      filter.getInput(0).getTable(),
      (Prepare.CatalogReader) filter.getInput(0).getTable().getRelOptSchema(),
      filter,
      TableModify.Operation.DELETE,
      null,
      null,
      false);
  String relJson = RelOptUtil.dumpPlan("", modify,
      SqlExplainFormat.JSON, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
  String s = deserializeAndDumpToTextFormat(getSchema(modify), relJson);
  final String expected = ""
      + "LogicalTableModify(table=[[scott, EMP]], operation=[DELETE], flattened=[false])\n"
      + "  LogicalFilter(condition=[=($2, 'c')])\n"
      + "    LogicalTableScan(table=[[scott, EMP]])\n";
  assertThat(s, isLinux(expected));
}
 

@Override
public TableModify toModificationRel(
    RelOptCluster cluster,
    RelOptTable table,
    Prepare.CatalogReader catalogReader,
    RelNode child,
    TableModify.Operation operation,
    List<String> updateColumnList,
    List<RexNode> sourceExpressionList,
    boolean flattened) {
    return LogicalTableModify.create(table, catalogReader, child, operation,
        updateColumnList, sourceExpressionList, flattened);
}
 

/**
 * Variant of {@link #trimFields(RelNode, ImmutableBitSet, Set)} for
 * {@link org.apache.calcite.rel.logical.LogicalTableModify}.
 */
public TrimResult trimFields(LogicalTableModify modifier, ImmutableBitSet fieldsUsed,
        Set<RelDataTypeField> extraFields) {
    // Ignore what consumer wants. We always project all columns.
    Util.discard(fieldsUsed);

    final RelDataType rowType = modifier.getRowType();
    final int fieldCount = rowType.getFieldCount();
    RelNode input = modifier.getInput();

    // We want all fields from the child.
    final int inputFieldCount = input.getRowType().getFieldCount();
    final ImmutableBitSet inputFieldsUsed = ImmutableBitSet.range(inputFieldCount);

    // Create input with trimmed columns.
    final Set<RelDataTypeField> inputExtraFields = Collections.emptySet();
    TrimResult trimResult = trimChild(modifier, input, inputFieldsUsed, inputExtraFields);
    RelNode newInput = trimResult.left;
    final Mapping inputMapping = trimResult.right;
    if (!inputMapping.isIdentity()) {
        // We asked for all fields. Can't believe that the child decided
        // to permute them!
        throw new AssertionError("Expected identity mapping, got " + inputMapping);
    }

    LogicalTableModify newModifier = modifier;
    if (newInput != input) {
        newModifier = modifier.copy(modifier.getTraitSet(), Collections.singletonList(newInput));
    }
    assert newModifier.getClass() == modifier.getClass();

    // Always project all fields.
    Mapping mapping = Mappings.createIdentity(fieldCount);
    return result(newModifier, mapping);
}
 

@Test void testTableModifyMerge() {
  final FrameworkConfig config = RelBuilderTest.config().build();
  final RelBuilder builder = RelBuilder.create(config);
  RelNode deptScan = builder.scan("DEPT").build();
  RelNode empScan = builder.scan("EMP").build();
  builder.push(deptScan);
  builder.push(empScan);
  RelNode project = builder
      .join(JoinRelType.LEFT,
          builder.call(
              SqlStdOperatorTable.EQUALS,
              builder.field(2, 0, "DEPTNO"),
              builder.field(2, 1, "DEPTNO")))
      .project(
          builder.literal(0),
          builder.literal("x"),
          builder.literal("x"),
          builder.literal(0),
          builder.literal("20200501 10:00:00"),
          builder.literal(0),
          builder.literal(0),
          builder.literal(0),
          builder.literal("false"),
          builder.field(1, 0, 2),
          builder.field(1, 0, 3),
          builder.field(1, 0, 4),
          builder.field(1, 0, 5),
          builder.field(1, 0, 6),
          builder.field(1, 0, 7),
          builder.field(1, 0, 8),
          builder.field(1, 0, 9),
          builder.field(1, 0, 10),
          builder.literal("a"))
      .build();
  // for sql:
  // merge into emp using dept on emp.deptno = dept.deptno
  // when matched then update set job = 'a'
  // when not matched then insert values(0, 'x', 'x', 0, '20200501 10:00:00', 0, 0, 0, 0)
  LogicalTableModify modify = LogicalTableModify.create(
      empScan.getTable(),
      (Prepare.CatalogReader) empScan.getTable().getRelOptSchema(),
      project,
      TableModify.Operation.MERGE,
      ImmutableList.of("ENAME"),
      null,
      false);
  String relJson = RelOptUtil.dumpPlan("", modify,
      SqlExplainFormat.JSON, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
  String s = deserializeAndDumpToTextFormat(getSchema(modify), relJson);
  final String expected = ""
      + "LogicalTableModify(table=[[scott, EMP]], operation=[MERGE], "
      + "updateColumnList=[[ENAME]], flattened=[false])\n"
      + "  LogicalProject($f0=[0], $f1=['x'], $f2=['x'], $f3=[0], $f4=['20200501 10:00:00'], "
      + "$f5=[0], $f6=[0], $f7=[0], $f8=['false'], LOC=[$2], EMPNO=[$3], ENAME=[$4], JOB=[$5], "
      + "MGR=[$6], HIREDATE=[$7], SAL=[$8], COMM=[$9], DEPTNO=[$10], $f18=['a'])\n"
      + "    LogicalJoin(condition=[=($0, $10)], joinType=[left])\n"
      + "      LogicalTableScan(table=[[scott, DEPT]])\n"
      + "      LogicalTableScan(table=[[scott, EMP]])\n";
  assertThat(s, isLinux(expected));
}
 

/**
 * Variant of {@link #trimFields(RelNode, ImmutableBitSet, Set)} for
 * {@link org.apache.calcite.rel.logical.LogicalTableModify}.
 */
public TrimResult trimFields(
    LogicalTableModify modifier,
    ImmutableBitSet fieldsUsed,
    Set<RelDataTypeField> extraFields) {
  // Ignore what consumer wants. We always project all columns.
  Util.discard(fieldsUsed);

  final RelDataType rowType = modifier.getRowType();
  final int fieldCount = rowType.getFieldCount();
  RelNode input = modifier.getInput();

  // We want all fields from the child.
  final int inputFieldCount = input.getRowType().getFieldCount();
  final ImmutableBitSet inputFieldsUsed =
      ImmutableBitSet.range(inputFieldCount);

  // Create input with trimmed columns.
  final Set<RelDataTypeField> inputExtraFields = Collections.emptySet();
  TrimResult trimResult =
      trimChild(modifier, input, inputFieldsUsed, inputExtraFields);
  RelNode newInput = trimResult.left;
  final Mapping inputMapping = trimResult.right;
  if (!inputMapping.isIdentity()) {
    // We asked for all fields. Can't believe that the child decided
    // to permute them!
    throw new AssertionError(
        "Expected identity mapping, got " + inputMapping);
  }

  LogicalTableModify newModifier = modifier;
  if (newInput != input) {
    newModifier =
        modifier.copy(
            modifier.getTraitSet(),
            Collections.singletonList(newInput));
  }
  assert newModifier.getClass() == modifier.getClass();

  // Always project all fields.
  Mapping mapping = Mappings.createIdentity(fieldCount);
  return result(newModifier, mapping);
}
 

public void rewriteRel(LogicalTableModify rel) {
    LogicalTableModify newRel = LogicalTableModify.create(rel.getTable(), rel.getCatalogReader(),
            getNewForOldRel(rel.getInput()), rel.getOperation(), rel.getUpdateColumnList(),
            rel.getSourceExpressionList(), true);
    setNewForOldRel(rel, newRel);
}
 

/**
 * Creates an EnumerableTableModifyRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public EnumerableTableModifyRule(RelBuilderFactory relBuilderFactory) {
  super(LogicalTableModify.class, (Predicate<RelNode>) r -> true,
      Convention.NONE, EnumerableConvention.INSTANCE, relBuilderFactory,
      "EnumerableTableModificationRule");
}
 

public LogicalTableModify.Operation getTableModOp() {
  return tableModOp;
}
 

public LogicalTableModify.Operation getTableModOp() {
  return null;
}
 

public RelNode visit(LogicalTableModify modify) {
  return modify;
}
 

public RelNode visit(LogicalTableModify modify) {
  return visitChildren(modify);
}
 

@Override
public TableModify toModificationRel(RelOptCluster cluster, RelOptTable table, Prepare.CatalogReader catalogReader, RelNode child, TableModify.Operation operation, List<String> updateColumnList, List<RexNode> sourceExpressionList, boolean flattened) {
    return LogicalTableModify.create(table, catalogReader, child, operation,
            updateColumnList, sourceExpressionList, flattened);
}
 

abstract public RelNode doApply(
LogicalTableModify tableModify, JournalledJdbcTable journalTable,
JdbcRelBuilderFactory relBuilderFactory);
 

@Override
public RelNode doApply(LogicalTableModify tableModify, JournalledJdbcTable journalTable,
		JdbcRelBuilderFactory relBuilderFactory) {

	if (!(tableModify.getInput() instanceof LogicalProject)) {
		throw new IllegalStateException("Unknown Calcite UPDATE structure");
	}

	String versionField = journalTable.getVersionField();

	// Merge the Update's update column expression into the target INSERT
	LogicalProject project = (LogicalProject) tableModify.getInput();
	List<RexNode> desiredFields = new ArrayList<>();
	List<String> desiredNames = new ArrayList<>();

	for (Pair<RexNode, String> field : project.getNamedProjects()) {
		if (field.getKey() instanceof RexInputRef) {
			int index = tableModify.getUpdateColumnList().indexOf(field.getValue());
			if (index != -1) {
				desiredFields.add(tableModify.getSourceExpressionList().get(index));
			}
			else {
				desiredFields.add(field.getKey());
			}
			desiredNames.add(field.getValue());
		}
	}

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

	relBuilder.push(project.getInput());

	JournalVersionType versionType = journalTable.getVersionType();
	if (!versionType.isValidSqlType(relBuilder.field(versionField).getType().getSqlTypeName())) {
		throw new IllegalStateException("Incorrect journalVersionType! Column 'version_number' is of type: "
				+ relBuilder.field(versionField).getType().getSqlTypeName()
				+ " but the journalVersionType is " + versionType);
	}
	if (versionType.updateRequiresExplicitVersion()) {
		RexNode newVersion = versionType.incrementVersion(relBuilder, relBuilder.field(versionField));
		desiredFields.add(newVersion);
		desiredNames.add(versionField);
	}

	relBuilder.project(desiredFields, desiredNames);

	// Convert the UPDATE into INSERT TableModify operations
	relBuilder.insertCopying(
			tableModify,
			journalTable.getJournalTable()
	);

	return relBuilder.build();
}
 

@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();

}