From 215b4c4386133d543cdd6b082660a2ef5cb21d1f Mon Sep 17 00:00:00 2001 From: Au_Miner <358671982@qq.com> Date: Mon, 25 May 2026 20:06:01 +0800 Subject: [PATCH] [FLINK-39322][table] Add restore tests for cascaded delta join --- .../exec/stream/DeltaJoinRestoreTest.java | 27 +- .../exec/stream/DeltaJoinTestPrograms.java | 242 ++++ ...ta-join-with-cache-and-calc-on-source.json | 1147 +++++++++++++++++ .../savepoint/_metadata | Bin 0 -> 25798 bytes .../plan/cascaded-delta-join-with-cache.json | 638 +++++++++ .../savepoint/_metadata | Bin 0 -> 26135 bytes ...calc-on-source-and-filter-pushed-down.json | 1146 ++++++++++++++++ .../savepoint/_metadata | Bin 0 -> 25587 bytes ...scaded-delta-join-with-calc-on-source.json | 1147 +++++++++++++++++ .../savepoint/_metadata | Bin 0 -> 25988 bytes ...lta-join-with-join-key-contains-index.json | 1015 +++++++++++++++ .../savepoint/_metadata | Bin 0 -> 26193 bytes ...delta-join-with-join-key-equals-index.json | 944 ++++++++++++++ .../savepoint/_metadata | Bin 0 -> 25668 bytes ...d-delta-join-with-non-equiv-condition.json | 639 +++++++++ .../savepoint/_metadata | Bin 0 -> 26141 bytes 16 files changed, 6944 insertions(+), 1 deletion(-) create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache-and-calc-on-source/plan/cascaded-delta-join-with-cache-and-calc-on-source.json create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache-and-calc-on-source/savepoint/_metadata create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache/plan/cascaded-delta-join-with-cache.json create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache/savepoint/_metadata create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source-and-filter-pushed-down/plan/cascaded-delta-join-with-calc-on-source-and-filter-pushed-down.json create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source-and-filter-pushed-down/savepoint/_metadata create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source/plan/cascaded-delta-join-with-calc-on-source.json create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source/savepoint/_metadata create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-contains-index/plan/cascaded-delta-join-with-join-key-contains-index.json create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-contains-index/savepoint/_metadata create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-equals-index/plan/cascaded-delta-join-with-join-key-equals-index.json create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-equals-index/savepoint/_metadata create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-non-equiv-condition/plan/cascaded-delta-join-with-non-equiv-condition.json create mode 100644 flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-non-equiv-condition/savepoint/_metadata diff --git a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/stream/DeltaJoinRestoreTest.java b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/stream/DeltaJoinRestoreTest.java index 38cf2bf787e4b..5962ed629a8e3 100644 --- a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/stream/DeltaJoinRestoreTest.java +++ b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/stream/DeltaJoinRestoreTest.java @@ -23,6 +23,7 @@ import java.util.Arrays; import java.util.List; +import java.util.Map; /** Restore tests for {@link StreamExecDeltaJoin}. */ public class DeltaJoinRestoreTest extends RestoreTestBase { @@ -44,6 +45,30 @@ public List programs() { DeltaJoinTestPrograms.DELTA_JOIN_WITH_CDC_SOURCE_WITHOUT_DELETE, DeltaJoinTestPrograms.DELTA_JOIN_WITH_CALC_ON_CDC_SOURCE_WITHOUT_DELETE, DeltaJoinTestPrograms.DELTA_JOIN_WITH_CACHE_AND_CDC_SOURCE_WITHOUT_DELETE, - DeltaJoinTestPrograms.DELTA_JOIN_WITH_CACHE_AND_CALC_ON_CDC_SOURCE_WITHOUT_DELETE); + DeltaJoinTestPrograms.DELTA_JOIN_WITH_CACHE_AND_CALC_ON_CDC_SOURCE_WITHOUT_DELETE, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_JOIN_KEY_EQUALS_INDEX, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_JOIN_KEY_CONTAINS_INDEX, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_NON_EQUIV_CONDITION, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE, + DeltaJoinTestPrograms + .CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE_AND_FILTER_PUSHED_DOWN, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_CACHE, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_CACHE_AND_CALC_ON_SOURCE); + } + + @Override + protected Map> programsToIgnore() { + // Cascaded delta join programs are only supported starting from version 2 + return Map.of( + 1, + List.of( + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_JOIN_KEY_EQUALS_INDEX, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_JOIN_KEY_CONTAINS_INDEX, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_NON_EQUIV_CONDITION, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE, + DeltaJoinTestPrograms + .CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE_AND_FILTER_PUSHED_DOWN, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_CACHE, + DeltaJoinTestPrograms.CASCADED_DELTA_JOIN_WITH_CACHE_AND_CALC_ON_SOURCE)); } } diff --git a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/stream/DeltaJoinTestPrograms.java b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/stream/DeltaJoinTestPrograms.java index 04b319c26a96c..2281aa270f7d3 100644 --- a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/stream/DeltaJoinTestPrograms.java +++ b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/plan/nodes/exec/stream/DeltaJoinTestPrograms.java @@ -41,12 +41,20 @@ public class DeltaJoinTestPrograms { static final String[] RIGHT_TABLE_BASE_SCHEMA = new String[] {"b0 double", "b2 string", "b1 int"}; + static final String[] SRC_C_TABLE_BASE_SCHEMA = + new String[] {"c1 int", "c0 double", "c2 string"}; + static final String[] SINK_TABLE_BASE_SCHEMA = Stream.concat( Arrays.stream(LEFT_TABLE_BASE_SCHEMA), Arrays.stream(RIGHT_TABLE_BASE_SCHEMA)) .toArray(String[]::new); + static final String[] CASCADED_SINK_TABLE_BASE_SCHEMA = + Stream.of(LEFT_TABLE_BASE_SCHEMA, RIGHT_TABLE_BASE_SCHEMA, SRC_C_TABLE_BASE_SCHEMA) + .flatMap(Arrays::stream) + .toArray(String[]::new); + static final Map TABLE_BASE_OPTIONS = Map.of("async", "true", "sink-insert-only", "false"); @@ -417,6 +425,240 @@ public class DeltaJoinTestPrograms { .sql) .build(); + // --- Cascaded Delta Join Test Programs (3-table join) --- + // All cascaded programs use CDC+PK sources (changelog-mode = I,UA,UB) because PK propagation + // through the inner join is required for the downstream join to be optimized into a delta join. + + public static final TableTestProgram CASCADED_DELTA_JOIN_WITH_JOIN_KEY_EQUALS_INDEX = + TableTestProgram.of( + "cascaded-delta-join-with-join-key-equals-index", + "validates cascaded delta join with join key equals index") + .setupConfig( + OptimizerConfigOptions.TABLE_OPTIMIZER_DELTA_JOIN_STRATEGY, + OptimizerConfigOptions.DeltaJoinStrategy.FORCE) + .setupTableSource( + SourceTestStep.newBuilder("srcA") + .addSchema(addPk2Schema(LEFT_TABLE_BASE_SCHEMA, "a1", "a0")) + .addOptions(TABLE_BASE_OPTIONS) + .addOption("changelog-mode", "I,UA,UB") + .addIndex("a1") + .producedBeforeRestore( + Row.ofKind(RowKind.INSERT, 1, 1.0, "a-1"), + Row.ofKind(RowKind.INSERT, 2, 2.0, "a-2"), + Row.ofKind(RowKind.INSERT, 5, 5.0, "a-5-1"), + Row.ofKind(RowKind.UPDATE_BEFORE, 5, 5.0, "a-5-1"), + Row.ofKind(RowKind.UPDATE_AFTER, 5, 5.0, "a-5-2")) + .treatDataBeforeRestoreAsConsumedData() + .producedAfterRestore( + Row.ofKind(RowKind.INSERT, 3, 3.0, "a-3"), + Row.ofKind(RowKind.UPDATE_BEFORE, 2, 2.0, "a-2"), + Row.ofKind(RowKind.UPDATE_AFTER, 2, 2.0, "a-2-u")) + .build()) + .setupTableSource( + SourceTestStep.newBuilder("srcB") + .addSchema(addPk2Schema(RIGHT_TABLE_BASE_SCHEMA, "b0", "b1")) + .addOptions(TABLE_BASE_OPTIONS) + .addOption("changelog-mode", "I,UA,UB") + .addIndex("b1") + .producedBeforeRestore( + Row.ofKind(RowKind.INSERT, 1.0, "b-1", 1), + Row.ofKind(RowKind.INSERT, 2.0, "b-2", 2), + Row.ofKind(RowKind.INSERT, 5.0, "b-5", 5)) + .treatDataBeforeRestoreAsConsumedData() + .producedAfterRestore(Row.ofKind(RowKind.INSERT, 3.0, "b-3", 3)) + .build()) + .setupTableSource( + SourceTestStep.newBuilder("srcC") + .addSchema(addPk2Schema(SRC_C_TABLE_BASE_SCHEMA, "c1", "c0")) + .addOptions(TABLE_BASE_OPTIONS) + .addOption("changelog-mode", "I,UA,UB") + .addIndex("c1") + .producedBeforeRestore( + Row.ofKind(RowKind.INSERT, 1, 1.0, "c-1"), + Row.ofKind(RowKind.INSERT, 2, 2.0, "c-2"), + Row.ofKind(RowKind.INSERT, 5, 5.0, "c-5")) + .treatDataBeforeRestoreAsConsumedData() + .producedAfterRestore( + Row.ofKind(RowKind.UPDATE_BEFORE, 5, 5.0, "c-5"), + Row.ofKind(RowKind.UPDATE_AFTER, 5, 5.0, "c-5-u"), + Row.ofKind(RowKind.INSERT, 3, 3.0, "c-3")) + .build()) + .setupTableSink( + SinkTestStep.newBuilder("snk") + .addSchema( + addPk2Schema( + CASCADED_SINK_TABLE_BASE_SCHEMA, + "a0", + "b0", + "c0", + "a1", + "b1", + "c1")) + .addOptions(TABLE_BASE_OPTIONS) + .testMaterializedData() + .deduplicatedFieldIndices(new int[] {0, 1, 3, 5, 6, 7}) + .consumedBeforeRestore( + Row.of(1, 1.0, "a-1", 1.0, "b-1", 1, 1, 1.0, "c-1"), + Row.of(2, 2.0, "a-2", 2.0, "b-2", 2, 2, 2.0, "c-2"), + Row.of(5, 5.0, "a-5-2", 5.0, "b-5", 5, 5, 5.0, "c-5")) + .consumedAfterRestore( + Row.of(1, 1.0, "a-1", 1.0, "b-1", 1, 1, 1.0, "c-1"), + Row.of(2, 2.0, "a-2-u", 2.0, "b-2", 2, 2, 2.0, "c-2"), + Row.of(3, 3.0, "a-3", 3.0, "b-3", 3, 3, 3.0, "c-3"), + Row.of(5, 5.0, "a-5-2", 5.0, "b-5", 5, 5, 5.0, "c-5-u")) + .build()) + .runSql( + "insert into snk " + + "select * from srcA join srcB " + + "on a1 = b1 " + + "join srcC on a1 = c1") + .build(); + + public static final TableTestProgram CASCADED_DELTA_JOIN_WITH_JOIN_KEY_CONTAINS_INDEX = + TableTestProgram.of( + "cascaded-delta-join-with-join-key-contains-index", + "validates cascaded delta join with join key contains index") + .setupConfig( + OptimizerConfigOptions.TABLE_OPTIMIZER_DELTA_JOIN_STRATEGY, + OptimizerConfigOptions.DeltaJoinStrategy.FORCE) + .setupTableSources( + CASCADED_DELTA_JOIN_WITH_JOIN_KEY_EQUALS_INDEX + .getSetupSourceTestSteps()) + .setupTableSinks( + CASCADED_DELTA_JOIN_WITH_JOIN_KEY_EQUALS_INDEX.getSetupSinkTestSteps()) + .runSql( + "insert into snk " + + "select * from srcA join srcB " + + "on a1 = b1 and a0 = b0 " + + "join srcC on a1 = c1") + .build(); + + public static final TableTestProgram CASCADED_DELTA_JOIN_WITH_NON_EQUIV_CONDITION = + TableTestProgram.of( + "cascaded-delta-join-with-non-equiv-condition", + "validates cascaded delta join with non equiv condition") + .setupConfig( + OptimizerConfigOptions.TABLE_OPTIMIZER_DELTA_JOIN_STRATEGY, + OptimizerConfigOptions.DeltaJoinStrategy.FORCE) + .setupTableSources( + CASCADED_DELTA_JOIN_WITH_JOIN_KEY_EQUALS_INDEX + .getSetupSourceTestSteps()) + .setupTableSinks( + CASCADED_DELTA_JOIN_WITH_JOIN_KEY_EQUALS_INDEX.getSetupSinkTestSteps()) + .runSql( + "insert into snk " + + "select * from srcA join srcB " + + "on a1 = b1 " + + "join srcC on a1 = c1 and a2 <> c2") + .build(); + + public static final TableTestProgram CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE = + TableTestProgram.of( + "cascaded-delta-join-with-calc-on-source", + "validates cascaded delta join with calc on source") + .setupConfig( + OptimizerConfigOptions.TABLE_OPTIMIZER_DELTA_JOIN_STRATEGY, + OptimizerConfigOptions.DeltaJoinStrategy.FORCE) + .setupTableSources( + CASCADED_DELTA_JOIN_WITH_JOIN_KEY_EQUALS_INDEX + .getSetupSourceTestSteps()) + .setupTableSink( + SinkTestStep.newBuilder("snk") + .addSchema( + addPk2Schema( + CASCADED_SINK_TABLE_BASE_SCHEMA, + "a0", + "b0", + "c0", + "a1", + "b1", + "c1")) + .addOptions(TABLE_BASE_OPTIONS) + .testMaterializedData() + .deduplicatedFieldIndices(new int[] {0, 1, 3, 5, 6, 7}) + .consumedBeforeRestore( + Row.of(2, 2.0, "a-2", 2.0, "b-2", 2, 2, 2.0, "c-2-s"), + Row.of(5, 5.0, "a-5-2", 5.0, "b-5", 5, 5, 5.0, "c-5-s")) + .consumedAfterRestore( + Row.of(2, 2.0, "a-2-u", 2.0, "b-2", 2, 2, 2.0, "c-2-s"), + Row.of( + 5, 5.0, "a-5-2", 5.0, "b-5", 5, 5, 5.0, + "c-5-u-s")) + .build()) + .runSql( + "insert into snk " + + "select a1, a0, a2, b0, b2, b1, c1, c0, new_c2 from " + + "srcA join srcB " + + "on a1 = b1 " + + "join (" + + " select c1, c0, concat(c2, '-s') as new_c2 from srcC " + + " where c1 = 2 or c1 = 5 " + + ") on a1 = c1") + .build(); + + public static final TableTestProgram + CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE_AND_FILTER_PUSHED_DOWN = + TableTestProgram.of( + "cascaded-delta-join-with-calc-on-source-and-filter-pushed-down", + "validates cascaded delta join with calc on source and filter pushed down") + .setupConfig( + OptimizerConfigOptions.TABLE_OPTIMIZER_DELTA_JOIN_STRATEGY, + OptimizerConfigOptions.DeltaJoinStrategy.FORCE) + .setupConfig( + ExecutionConfigOptions.TABLE_EXEC_DELTA_JOIN_CACHE_ENABLED, + true) + .setupTableSources( + CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE + .getSetupSourceTestSteps() + .stream() + .map( + sourceTestStep -> { + if (!sourceTestStep.name.equals("srcC")) { + return sourceTestStep; + } + Map oldOptions = + new HashMap<>( + sourceTestStep.options); + oldOptions.put("filterable-fields", "c1"); + return sourceTestStep.withNewOptions( + oldOptions); + }) + .collect(Collectors.toList())) + .setupTableSinks( + CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE.getSetupSinkTestSteps()) + .runSql(CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE.getRunSqlTestStep().sql) + .build(); + + public static final TableTestProgram CASCADED_DELTA_JOIN_WITH_CACHE = + TableTestProgram.of( + "cascaded-delta-join-with-cache", + "validates cascaded delta join with cache") + .setupConfig( + OptimizerConfigOptions.TABLE_OPTIMIZER_DELTA_JOIN_STRATEGY, + OptimizerConfigOptions.DeltaJoinStrategy.FORCE) + .setupConfig(ExecutionConfigOptions.TABLE_EXEC_DELTA_JOIN_CACHE_ENABLED, true) + .setupTableSources( + CASCADED_DELTA_JOIN_WITH_NON_EQUIV_CONDITION.getSetupSourceTestSteps()) + .setupTableSinks( + CASCADED_DELTA_JOIN_WITH_NON_EQUIV_CONDITION.getSetupSinkTestSteps()) + .runSql(CASCADED_DELTA_JOIN_WITH_NON_EQUIV_CONDITION.getRunSqlTestStep().sql) + .build(); + + public static final TableTestProgram CASCADED_DELTA_JOIN_WITH_CACHE_AND_CALC_ON_SOURCE = + TableTestProgram.of( + "cascaded-delta-join-with-cache-and-calc-on-source", + "validates cascaded delta join with cache and calc on source") + .setupConfig( + OptimizerConfigOptions.TABLE_OPTIMIZER_DELTA_JOIN_STRATEGY, + OptimizerConfigOptions.DeltaJoinStrategy.FORCE) + .setupConfig(ExecutionConfigOptions.TABLE_EXEC_DELTA_JOIN_CACHE_ENABLED, true) + .setupTableSources( + CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE.getSetupSourceTestSteps()) + .setupTableSinks( + CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE.getSetupSinkTestSteps()) + .runSql(CASCADED_DELTA_JOIN_WITH_CALC_ON_SOURCE.getRunSqlTestStep().sql) + .build(); + private static String[] addPk2Schema(String[] originalSchema, String... pkCols) { return Stream.concat( Arrays.stream(originalSchema), diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache-and-calc-on-source/plan/cascaded-delta-join-with-cache-and-calc-on-source.json b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache-and-calc-on-source/plan/cascaded-delta-join-with-cache-and-calc-on-source.json new file mode 100644 index 0000000000000..581755110d82c --- /dev/null +++ b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache-and-calc-on-source/plan/cascaded-delta-join-with-cache-and-calc-on-source.json @@ -0,0 +1,1147 @@ +{ + "flinkVersion" : "2.3", + "nodes" : [ { + "id" : 55, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcA]], fields=[a1, a0, a2])" + }, { + "id" : 56, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 57, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 58, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcB]], fields=[b0, b2, b1])" + }, { + "id" : 59, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DropUpdateBefore" + }, { + "id" : 60, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 2 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[b1]])" + }, { + "id" : 61, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1 ], + "rightJoinKeys" : [ 2 ], + "rightUpsertKey" : [ 0, 2 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 1 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 2 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = b1)], leftToRight=[Binary], rightToLeft=[Binary], select=[a1, a0, a2, b0, b2, b1])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 62, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 63, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + }, + "abilities" : [ { + "type" : "FilterPushDown", + "predicates" : [ ] + } ] + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcC, filter=[]]], fields=[c1, c0, c2])" + }, { + "id" : 64, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 65, + "type" : "stream-exec-calc_1", + "projection" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "CALL", + "internalName" : "$CONCAT$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "LITERAL", + "value" : "-s", + "type" : "CHAR(2) NOT NULL" + } ], + "type" : "VARCHAR(2147483647)" + } ], + "condition" : { + "kind" : "CALL", + "syntax" : "INTERNAL", + "internalName" : "$SEARCH$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "LITERAL", + "sarg" : { + "ranges" : [ { + "lower" : { + "value" : 2, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 2, + "boundType" : "CLOSED" + } + }, { + "lower" : { + "value" : 5, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 5, + "boundType" : "CLOSED" + } + } ], + "nullAs" : "UNKNOWN" + }, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "Calc(select=[c1, c0, CONCAT(c2, '-s') AS new_c2], where=[SEARCH(c1, Sarg[2, 5])])" + }, { + "id" : 66, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[c1]])" + }, { + "id" : 67, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1, 3, 5 ], + "rightJoinKeys" : [ 0 ], + "rightUpsertKey" : [ 0, 1 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0, 1 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0, 1 ], + "lookupTableBinaryInputOrdinal" : 2, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + }, + "abilities" : [ { + "type" : "FilterPushDown", + "predicates" : [ ] + } ] + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null, + "projectionOnTemporalTable" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "CALL", + "internalName" : "$CONCAT$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "LITERAL", + "value" : "-s", + "type" : "CHAR(2) NOT NULL" + } ], + "type" : "VARCHAR(2147483647)" + } ], + "filterOnTemporalTable" : { + "kind" : "CALL", + "syntax" : "INTERNAL", + "internalName" : "$SEARCH$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "LITERAL", + "sarg" : { + "ranges" : [ { + "lower" : { + "value" : 2, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 2, + "boundType" : "CLOSED" + } + }, { + "lower" : { + "value" : 5, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 5, + "boundType" : "CLOSED" + } + } ], + "nullAs" : "UNKNOWN" + }, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + } + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 2 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + }, { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + }, + "abilities" : [ { + "type" : "FilterPushDown", + "predicates" : [ ] + } ] + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 0 ], + "left" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 2, + "projection" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "CALL", + "internalName" : "$CONCAT$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "LITERAL", + "value" : "-s", + "type" : "CHAR(2) NOT NULL" + } ], + "type" : "VARCHAR(2147483647)" + } ], + "filter" : { + "kind" : "CALL", + "syntax" : "INTERNAL", + "internalName" : "$SEARCH$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "LITERAL", + "sarg" : { + "ranges" : [ { + "lower" : { + "value" : 2, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 2, + "boundType" : "CLOSED" + } + }, { + "lower" : { + "value" : 5, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 5, + "boundType" : "CLOSED" + } + } ], + "nullAs" : "UNKNOWN" + }, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "rowTypeAfterCalc" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "rowType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = c1)], leftToRight=[Binary], rightToLeft=[[{round=[1], sourceTables=[default_catalog.default_database.srcC], lookupTable=[default_catalog.default_database.srcA], lookupKeys=[a1=c1]}, {round=[2], sourceTables=[default_catalog.default_database.srcA], lookupTable=[default_catalog.default_database.srcB], lookupKeys=[b1=a1]}]], select=[a1, a0, a2, b0, b2, b1, c1, c0, new_c2])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 68, + "type" : "stream-exec-sink_2", + "configuration" : { + "table.exec.sink.keyed-shuffle" : "AUTO", + "table.exec.sink.not-null-enforcer" : "ERROR", + "table.exec.sink.rowtime-inserter" : "ENABLED", + "table.exec.sink.type-length-enforcer" : "IGNORE", + "table.exec.sink.upsert-materialize" : "AUTO" + }, + "dynamicTableSink" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`snk`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a0_b0_c0_a1_b1_c1", + "type" : "PRIMARY_KEY", + "columns" : [ "a0", "b0", "c0", "a1", "b1", "c1" ] + } + } + } + } + }, + "inputChangelogMode" : [ "INSERT", "UPDATE_AFTER" ], + "upsertMaterializeStrategy" : "VALUE", + "inputUpsertKey" : [ 0, 1, 3, 5, 6, 7 ], + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "Sink(table=[default_catalog.default_database.snk], fields=[a1, a0, a2, b0, b2, b1, c1, c0, new_c2])" + } ], + "edges" : [ { + "source" : 55, + "target" : 56, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 56, + "target" : 57, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 58, + "target" : 59, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 59, + "target" : 60, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 57, + "target" : 61, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 60, + "target" : 61, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 61, + "target" : 62, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 63, + "target" : 64, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 64, + "target" : 65, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 65, + "target" : 66, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 62, + "target" : 67, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 66, + "target" : 67, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 67, + "target" : 68, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + } ] +} \ No newline at end of file diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache-and-calc-on-source/savepoint/_metadata b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache-and-calc-on-source/savepoint/_metadata new file mode 100644 index 0000000000000000000000000000000000000000..d6dd41527c8894a4e71a8cfa8707c03e00ea7575 GIT binary patch literal 25798 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 TJkdk%b_nf|+@Bnd4i5YWk}xba literal 0 HcmV?d00001 diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache/plan/cascaded-delta-join-with-cache.json b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache/plan/cascaded-delta-join-with-cache.json new file mode 100644 index 0000000000000..a8bfbd71538b8 --- /dev/null +++ b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache/plan/cascaded-delta-join-with-cache.json @@ -0,0 +1,638 @@ +{ + "flinkVersion" : "2.3", + "nodes" : [ { + "id" : 68, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcA]], fields=[a1, a0, a2])" + }, { + "id" : 69, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 70, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 71, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcB]], fields=[b0, b2, b1])" + }, { + "id" : 72, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DropUpdateBefore" + }, { + "id" : 73, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 2 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[b1]])" + }, { + "id" : 74, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1 ], + "rightJoinKeys" : [ 2 ], + "rightUpsertKey" : [ 0, 2 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 1 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 2 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = b1)], leftToRight=[Binary], rightToLeft=[Binary], select=[a1, a0, a2, b0, b2, b1])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 75, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 76, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcC]], fields=[c1, c0, c2])" + }, { + "id" : 77, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 78, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[c1]])" + }, { + "id" : 79, + "type" : "stream-exec-join_1", + "joinSpec" : { + "joinType" : "INNER", + "leftKeys" : [ 0 ], + "rightKeys" : [ 0 ], + "filterNulls" : [ true ], + "nonEquiCondition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$<>$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 8, + "type" : "VARCHAR(2147483647)" + } ], + "type" : "BOOLEAN" + } + }, + "leftUpsertKeys" : [ [ 0, 1, 3, 5 ] ], + "rightUpsertKeys" : [ [ 0, 1 ] ], + "state" : [ { + "index" : 0, + "ttl" : "0 ms", + "name" : "leftState" + }, { + "index" : 1, + "ttl" : "0 ms", + "name" : "rightState" + } ], + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Join(joinType=[InnerJoin], where=[((a1 = c1) AND (a2 <> c2))], select=[a1, a0, a2, b0, b2, b1, c1, c0, c2], leftInputSpec=[HasUniqueKey], rightInputSpec=[HasUniqueKey])" + }, { + "id" : 80, + "type" : "stream-exec-sink_2", + "configuration" : { + "table.exec.sink.keyed-shuffle" : "AUTO", + "table.exec.sink.not-null-enforcer" : "ERROR", + "table.exec.sink.rowtime-inserter" : "ENABLED", + "table.exec.sink.type-length-enforcer" : "IGNORE", + "table.exec.sink.upsert-materialize" : "AUTO" + }, + "dynamicTableSink" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`snk`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a0_b0_c0_a1_b1_c1", + "type" : "PRIMARY_KEY", + "columns" : [ "a0", "b0", "c0", "a1", "b1", "c1" ] + } + } + } + } + }, + "inputChangelogMode" : [ "INSERT", "UPDATE_AFTER" ], + "inputUpsertKey" : [ 0, 1, 3, 5, 6, 7 ], + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Sink(table=[default_catalog.default_database.snk], fields=[a1, a0, a2, b0, b2, b1, c1, c0, c2])" + } ], + "edges" : [ { + "source" : 68, + "target" : 69, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 69, + "target" : 70, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 71, + "target" : 72, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 72, + "target" : 73, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 70, + "target" : 74, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 73, + "target" : 74, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 74, + "target" : 75, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 76, + "target" : 77, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 77, + "target" : 78, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 75, + "target" : 79, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 78, + "target" : 79, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 79, + "target" : 80, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + } ] +} \ No newline at end of file diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache/savepoint/_metadata b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-cache/savepoint/_metadata new file mode 100644 index 0000000000000000000000000000000000000000..764a4d7d4ceb351c03ef8cd85290b870f8f52803 GIT binary patch literal 26135 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 IG&MZ", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcA]], fields=[a1, a0, a2])" + }, { + "id" : 42, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 43, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 44, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcB]], fields=[b0, b2, b1])" + }, { + "id" : 45, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DropUpdateBefore" + }, { + "id" : 46, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 2 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[b1]])" + }, { + "id" : 47, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1 ], + "rightJoinKeys" : [ 2 ], + "rightUpsertKey" : [ 0, 2 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 1 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 2 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = b1)], leftToRight=[Binary], rightToLeft=[Binary], select=[a1, a0, a2, b0, b2, b1])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 48, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 49, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + }, + "abilities" : [ { + "type" : "FilterPushDown", + "predicates" : [ ] + } ] + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcC, filter=[]]], fields=[c1, c0, c2])" + }, { + "id" : 50, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 51, + "type" : "stream-exec-calc_1", + "projection" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "CALL", + "internalName" : "$CONCAT$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "LITERAL", + "value" : "-s", + "type" : "CHAR(2) NOT NULL" + } ], + "type" : "VARCHAR(2147483647)" + } ], + "condition" : { + "kind" : "CALL", + "syntax" : "INTERNAL", + "internalName" : "$SEARCH$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "LITERAL", + "sarg" : { + "ranges" : [ { + "lower" : { + "value" : 2, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 2, + "boundType" : "CLOSED" + } + }, { + "lower" : { + "value" : 5, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 5, + "boundType" : "CLOSED" + } + } ], + "nullAs" : "UNKNOWN" + }, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "Calc(select=[c1, c0, CONCAT(c2, '-s') AS new_c2], where=[SEARCH(c1, Sarg[2, 5])])" + }, { + "id" : 52, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[c1]])" + }, { + "id" : 53, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1, 3, 5 ], + "rightJoinKeys" : [ 0 ], + "rightUpsertKey" : [ 0, 1 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0, 1 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0, 1 ], + "lookupTableBinaryInputOrdinal" : 2, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + }, + "abilities" : [ { + "type" : "FilterPushDown", + "predicates" : [ ] + } ] + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null, + "projectionOnTemporalTable" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "CALL", + "internalName" : "$CONCAT$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "LITERAL", + "value" : "-s", + "type" : "CHAR(2) NOT NULL" + } ], + "type" : "VARCHAR(2147483647)" + } ], + "filterOnTemporalTable" : { + "kind" : "CALL", + "syntax" : "INTERNAL", + "internalName" : "$SEARCH$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "LITERAL", + "sarg" : { + "ranges" : [ { + "lower" : { + "value" : 2, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 2, + "boundType" : "CLOSED" + } + }, { + "lower" : { + "value" : 5, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 5, + "boundType" : "CLOSED" + } + } ], + "nullAs" : "UNKNOWN" + }, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + } + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 2 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + }, { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + }, + "abilities" : [ { + "type" : "FilterPushDown", + "predicates" : [ ] + } ] + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 0 ], + "left" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 2, + "projection" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "CALL", + "internalName" : "$CONCAT$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "LITERAL", + "value" : "-s", + "type" : "CHAR(2) NOT NULL" + } ], + "type" : "VARCHAR(2147483647)" + } ], + "filter" : { + "kind" : "CALL", + "syntax" : "INTERNAL", + "internalName" : "$SEARCH$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "LITERAL", + "sarg" : { + "ranges" : [ { + "lower" : { + "value" : 2, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 2, + "boundType" : "CLOSED" + } + }, { + "lower" : { + "value" : 5, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 5, + "boundType" : "CLOSED" + } + } ], + "nullAs" : "UNKNOWN" + }, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "rowTypeAfterCalc" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "rowType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = c1)], leftToRight=[Binary], rightToLeft=[[{round=[1], sourceTables=[default_catalog.default_database.srcC], lookupTable=[default_catalog.default_database.srcA], lookupKeys=[a1=c1]}, {round=[2], sourceTables=[default_catalog.default_database.srcA], lookupTable=[default_catalog.default_database.srcB], lookupKeys=[b1=a1]}]], select=[a1, a0, a2, b0, b2, b1, c1, c0, new_c2])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 54, + "type" : "stream-exec-sink_2", + "configuration" : { + "table.exec.sink.keyed-shuffle" : "AUTO", + "table.exec.sink.not-null-enforcer" : "ERROR", + "table.exec.sink.rowtime-inserter" : "ENABLED", + "table.exec.sink.type-length-enforcer" : "IGNORE", + "table.exec.sink.upsert-materialize" : "AUTO" + }, + "dynamicTableSink" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`snk`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a0_b0_c0_a1_b1_c1", + "type" : "PRIMARY_KEY", + "columns" : [ "a0", "b0", "c0", "a1", "b1", "c1" ] + } + } + } + } + }, + "inputChangelogMode" : [ "INSERT", "UPDATE_AFTER" ], + "inputUpsertKey" : [ 0, 1, 3, 5, 6, 7 ], + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "Sink(table=[default_catalog.default_database.snk], fields=[a1, a0, a2, b0, b2, b1, c1, c0, new_c2])" + } ], + "edges" : [ { + "source" : 41, + "target" : 42, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 42, + "target" : 43, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 44, + "target" : 45, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 45, + "target" : 46, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 43, + "target" : 47, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 46, + "target" : 47, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 47, + "target" : 48, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 49, + "target" : 50, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 50, + "target" : 51, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 51, + "target" : 52, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 48, + "target" : 53, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 52, + "target" : 53, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 53, + "target" : 54, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + } ] +} \ No newline at end of file diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source-and-filter-pushed-down/savepoint/_metadata b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source-and-filter-pushed-down/savepoint/_metadata new file mode 100644 index 0000000000000000000000000000000000000000..657193b4cb674cfbbc371c7bc4680ae49b8a2dd2 GIT binary patch literal 25587 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 RRB7r3(?EJhdL%Iv{~t>`5xf8Z literal 0 HcmV?d00001 diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source/plan/cascaded-delta-join-with-calc-on-source.json b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source/plan/cascaded-delta-join-with-calc-on-source.json new file mode 100644 index 0000000000000..275d3d8c71671 --- /dev/null +++ b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source/plan/cascaded-delta-join-with-calc-on-source.json @@ -0,0 +1,1147 @@ +{ + "flinkVersion" : "2.3", + "nodes" : [ { + "id" : 27, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcA]], fields=[a1, a0, a2])" + }, { + "id" : 28, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 29, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 30, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcB]], fields=[b0, b2, b1])" + }, { + "id" : 31, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DropUpdateBefore" + }, { + "id" : 32, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 2 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[b1]])" + }, { + "id" : 33, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1 ], + "rightJoinKeys" : [ 2 ], + "rightUpsertKey" : [ 0, 2 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 1 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 2 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = b1)], leftToRight=[Binary], rightToLeft=[Binary], select=[a1, a0, a2, b0, b2, b1])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 34, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 35, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + }, + "abilities" : [ { + "type" : "FilterPushDown", + "predicates" : [ ] + } ] + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcC, filter=[]]], fields=[c1, c0, c2])" + }, { + "id" : 36, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 37, + "type" : "stream-exec-calc_1", + "projection" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "CALL", + "internalName" : "$CONCAT$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "LITERAL", + "value" : "-s", + "type" : "CHAR(2) NOT NULL" + } ], + "type" : "VARCHAR(2147483647)" + } ], + "condition" : { + "kind" : "CALL", + "syntax" : "INTERNAL", + "internalName" : "$SEARCH$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "LITERAL", + "sarg" : { + "ranges" : [ { + "lower" : { + "value" : 2, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 2, + "boundType" : "CLOSED" + } + }, { + "lower" : { + "value" : 5, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 5, + "boundType" : "CLOSED" + } + } ], + "nullAs" : "UNKNOWN" + }, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "Calc(select=[c1, c0, CONCAT(c2, '-s') AS new_c2], where=[SEARCH(c1, Sarg[2, 5])])" + }, { + "id" : 38, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[c1]])" + }, { + "id" : 39, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1, 3, 5 ], + "rightJoinKeys" : [ 0 ], + "rightUpsertKey" : [ 0, 1 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0, 1 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0, 1 ], + "lookupTableBinaryInputOrdinal" : 2, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + }, + "abilities" : [ { + "type" : "FilterPushDown", + "predicates" : [ ] + } ] + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null, + "projectionOnTemporalTable" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "CALL", + "internalName" : "$CONCAT$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "LITERAL", + "value" : "-s", + "type" : "CHAR(2) NOT NULL" + } ], + "type" : "VARCHAR(2147483647)" + } ], + "filterOnTemporalTable" : { + "kind" : "CALL", + "syntax" : "INTERNAL", + "internalName" : "$SEARCH$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "LITERAL", + "sarg" : { + "ranges" : [ { + "lower" : { + "value" : 2, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 2, + "boundType" : "CLOSED" + } + }, { + "lower" : { + "value" : 5, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 5, + "boundType" : "CLOSED" + } + } ], + "nullAs" : "UNKNOWN" + }, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + } + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 2 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + }, { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + }, + "abilities" : [ { + "type" : "FilterPushDown", + "predicates" : [ ] + } ] + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 0 ], + "left" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 2, + "projection" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "CALL", + "internalName" : "$CONCAT$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "LITERAL", + "value" : "-s", + "type" : "CHAR(2) NOT NULL" + } ], + "type" : "VARCHAR(2147483647)" + } ], + "filter" : { + "kind" : "CALL", + "syntax" : "INTERNAL", + "internalName" : "$SEARCH$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "LITERAL", + "sarg" : { + "ranges" : [ { + "lower" : { + "value" : 2, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 2, + "boundType" : "CLOSED" + } + }, { + "lower" : { + "value" : 5, + "boundType" : "CLOSED" + }, + "upper" : { + "value" : 5, + "boundType" : "CLOSED" + } + } ], + "nullAs" : "UNKNOWN" + }, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "rowTypeAfterCalc" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "rowType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = c1)], leftToRight=[Binary], rightToLeft=[[{round=[1], sourceTables=[default_catalog.default_database.srcC], lookupTable=[default_catalog.default_database.srcA], lookupKeys=[a1=c1]}, {round=[2], sourceTables=[default_catalog.default_database.srcA], lookupTable=[default_catalog.default_database.srcB], lookupKeys=[b1=a1]}]], select=[a1, a0, a2, b0, b2, b1, c1, c0, new_c2])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 40, + "type" : "stream-exec-sink_2", + "configuration" : { + "table.exec.sink.keyed-shuffle" : "AUTO", + "table.exec.sink.not-null-enforcer" : "ERROR", + "table.exec.sink.rowtime-inserter" : "ENABLED", + "table.exec.sink.type-length-enforcer" : "IGNORE", + "table.exec.sink.upsert-materialize" : "AUTO" + }, + "dynamicTableSink" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`snk`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a0_b0_c0_a1_b1_c1", + "type" : "PRIMARY_KEY", + "columns" : [ "a0", "b0", "c0", "a1", "b1", "c1" ] + } + } + } + } + }, + "inputChangelogMode" : [ "INSERT", "UPDATE_AFTER" ], + "upsertMaterializeStrategy" : "MAP", + "inputUpsertKey" : [ 0, 1, 3, 5, 6, 7 ], + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `new_c2` VARCHAR(2147483647)>", + "description" : "Sink(table=[default_catalog.default_database.snk], fields=[a1, a0, a2, b0, b2, b1, c1, c0, new_c2])" + } ], + "edges" : [ { + "source" : 27, + "target" : 28, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 28, + "target" : 29, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 30, + "target" : 31, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 31, + "target" : 32, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 29, + "target" : 33, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 32, + "target" : 33, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 33, + "target" : 34, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 35, + "target" : 36, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 36, + "target" : 37, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 37, + "target" : 38, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 34, + "target" : 39, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 38, + "target" : 39, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 39, + "target" : 40, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + } ] +} \ No newline at end of file diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source/savepoint/_metadata b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-calc-on-source/savepoint/_metadata new file mode 100644 index 0000000000000000000000000000000000000000..8c3b6be457a0049e519aa767cb97e4fe1ba6981e GIT binary patch literal 25988 zcmeGlZEPIHb?$7O7!%?I6A~!Ys7};C_CEIG_AXH?&i17ox!A_%Bw#na&h5_Go80YP zclR78s)A`mK&n)JP*kO;kRK^6Rr(TOX%zOLh&AasHCpm;r2Yl!isNGN(>KQc3l|2;|Tcn>9 z$_AO>kB`sDsRa{*WLEh`)ok76qo~%KD)2(Y`JPE zWP7h^C<7CMv>$Z}QqE+F$=BXCPgef?yC42$=6L?OvolbSf|(7VUNNf51yL4oM2-+q z&F5okOpeE6F+ML5RgOck>+IriW0!+LpdEe&(7IZ~qXetO$Xd`pyVPR^tw^?qr?C+( zl#7sQhLt1XsCvYjJ~VYen$8QNWEK;;T$xhDQUtC^JvmJ!$Y~OX9e5ko6!mNre2G$~6A4HvZ|#OOO;W>&`)bE<4XyKV4kyw(ho zqJ{4P0!|2t{b-Gl$f-1iI{-*?pu-1Udz*S5d$t!JPr;}HtN8F2<~75fJ6 zvG14Z?c=vxril4ytw;*=Zd;LPFCo$awA?E^=0%kx@_8;H6?jgJ#9|zdVUdf(3Q9qW z#EBSF5W4+S&}k-sgJ{gN^jbJyBq5`!TUv>@R^QR`p+Rh6*E;J-nYXwGPM<~BmJi&D20NRu7J&Yc+GIS}f8IWzcHc+-SLM zStynPu;H4(2{VBcX1xwGjKVfXVHa3hZ^ujp9W{`+Sd?g8hs)NpUR{3xPvcM#>yx3B zUM;yZD;8Rn9vVx121H}ezW+g1P2diBT5T;Nfs(FKYWUSKLIJd;Cf{;YzU9glVqmLm z9CLEXDj_ooJJnLl>_ND8%QK=MO=5H%O=$wlCu(M%WO4XCd9 zYfYDOlVqSNXhvE(jy0XZ;p4GtrAX>jX#zZmwwwnbtsY`PMAx{qqe)L4(=rGyX)v}< z+qD#fC}l$pWm$HrNJ^w(m|CPaMbu4&rJTSW{sg9L%7so~n|fgni`14_w%E)qe}m;J zEK{^OXSQ9vD`3aq@Sgrm%BJ7KWWZi*3`}98k${0T>L?O@(we&bWJzFIWXay-=)m2{ z(Fe|*JLj__s2LYBpM7?ORjID1%~Ol)ia@c{ELOJy66|EJ{n(V4; zSAFvn8nl@47V^+hm#AE1EL>wK%%V$Fs=J1!wR z`ep{-%+P9QvzbMquUTS)O6Hpx+^#fBVY=uUO72c&N0I{`hoQY56Ov;*VjGsBy=6@u z!X;vYPmycaudhXV!?;p==7z`MtJ|?`UgJE#{U2_(9_swXE_VrpdhWuU#PJ9{RLkwT zE6+*v@t9MN?&3kXvC?UcJ%g4Dp$ZRmz;3EH&@!kY2AEDBL@Srnp8To#W!GXBoG zm!G-!p|jKJ-LLfh7y!^t&r(42q1okjS?r$>BGhFuV!JFJ``%;kZr=Ku75)Cv4`T1G z`y|w7@W3}OE?|-n3Nc>d6DoN22~k{-NkI`}g;+GouOyd6IWF=MNiJ|=OaPZfQHpao zq82zM7LUrJB*fzJ2=x5wby?gnP}WV$z~J+l(!pz1A;yFVjB=A0$tiPL+%&jGf@f{n z81Ia9oq6-;C!TwM*RkV|j~fo#Q1)908zv`s8Q74QZ8m&k>#OqZcShGg`*8n>%|ChZ z6$c)$p{fA;MFp9U@_7OHE-%DokxwLeDX%Iqr2s`&is!7X#05na<6MErQShsZM>wp; z6;2c)vLfbV`KY2ocdlMGTs?q`%7g%{u}YA0@LsO;e6#E6u6JJF_?HtWC%^vYQl+ke>-pd(gip@e_=6!0l$Ax)s)|Viort2`G6&|Zv6sI1N*wTuZuV6%1eEG=F0NqU{kHh zK7EYt)5n_Z)Bo$GFYOC{_B;0~cWl%*Kam>-03W_@m4%o!5Lie*$o5`W!QQJ$quBiR z@fY5D_5C$(zxw{Bo4)vq*PDT|V+37C%X0=Xt3}JCINQN#ZaPhWAhfY|LmS6F0;4t& z;xS2(xL8yqoXEpQJease4vXMf01gH?5fuQ#Zv%>8)DEEeeWB#L)DeTc4nVD(yHYb2 zF?3vXolf&6HB2x&)_^Us?)11CxleEJ)JRb^=?OKeQ@;I!(;xfpgHPpxD3C$d7igZ7 zWm>2^Lt_(!>Cv_@4Rx>s&LnR>FLbB!i;w=h=gHu)QV<0*Xf15(PeZIIt*j3eu?c|J z)d16Y5@D9KBZIo^a~%{d3-OB%cmbxSX#?HtMUSn<5c$Jq$hIJafIwZWulPNFLf9}287?^-!p$)DPt{1Bf?+taxEE*V{Uo#K>>edr4;cv7d2m{b=LTE4u;DS)+ zp?3NW{gJ%f&0^nJjK}Q>6ta1u5AHkZjIJ|B8!)~~OvTVDHKtzg;^~_IDCKD#CIzLy zE$~c1)93b?3PgGd;^=}|vq^Xy3TO>FN^jluurZ8NZ)VUV0R3XDPK^!Nny3pt5AZKd zbOzQ^V6H2!W8(GZ@)7pjhiKs~u5_L~-w~kc+i0W%S6-Ao-^S|n*3*?%=`Gq&JZ;R- z);2MSR5;hU>ihyDX_ZTw;wRbiQl1#cPd|QZ*H_PcnF6bLx}5~jt}3+?+OyC8?4GR$ z|Jx3b2OY??UxTc=o6_^D*SP!SKTpMv?0B}n-s1d0NK$BNFEpCGn4>>h2v16b1_A8g8`-EJU97>^Khg$P0{=)GmA~hS!uC;F z%r8ciE>uvujx*L3jTIZp&Np5)sFJS1UG&Q6Qi*)oatUOMZ^!rT_;eEbJ~fvxKI*bd zW|u4ywycnR^o-mH`WUQ4k9u@o>@E`_OTIb!RVXt9S#=a&cfb`JI|9&*E6>^aQ& zU5C4^OvOF6K<7j;{3(HQko~DbXkhMf1pbnO7?wuZ zW(|M|2GQzq)U9f!f(>;5>k0u2sXC6<*hxDv{MiHiUhDkUbj_S{r(~;nvs$7l4w!7! ztPowLNgeELA3Stcb)|?QG`9*y@H%c(BWh~rx4RLp7Y#eh1g%5GAH4zyYuozf~WEBr`x;=x%RQ&3f&|yAO6EJdl7E5R+B#5P{+yn!`KP1aC${_*%$@e&;}P yXm}_+kj%i&jXlD>b1(q`AjiCa!)U^aa~0?)H0_NWCu%(F1QT&~Pj)0VH28mzdGT!k literal 0 HcmV?d00001 diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-contains-index/plan/cascaded-delta-join-with-join-key-contains-index.json b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-contains-index/plan/cascaded-delta-join-with-join-key-contains-index.json new file mode 100644 index 0000000000000..f30a4e0a74867 --- /dev/null +++ b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-contains-index/plan/cascaded-delta-join-with-join-key-contains-index.json @@ -0,0 +1,1015 @@ +{ + "flinkVersion" : "2.3", + "nodes" : [ { + "id" : 14, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcA]], fields=[a1, a0, a2])" + }, { + "id" : 15, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 16, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0, 1 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[a1, a0]])" + }, { + "id" : 17, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcB]], fields=[b0, b2, b1])" + }, { + "id" : 18, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DropUpdateBefore" + }, { + "id" : 19, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 2, 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[b1, b0]])" + }, { + "id" : 20, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0, 1 ], + "leftUpsertKey" : [ 0, 1 ], + "rightJoinKeys" : [ 2, 0 ], + "rightUpsertKey" : [ 0, 2 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$AND$1", + "operands" : [ { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 3, + "type" : "DOUBLE NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 1 + }, + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 1 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 2 + }, + "1" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$AND$1", + "operands" : [ { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 3, + "type" : "DOUBLE NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0, 1 ], + "rightJoinKey" : [ 2, 0 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[((a1 = b1) AND (a0 = b0))], leftToRight=[Binary], rightToLeft=[Binary], select=[a1, a0, a2, b0, b2, b1])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 21, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 22, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcC]], fields=[c1, c0, c2])" + }, { + "id" : 23, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 24, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[c1]])" + }, { + "id" : 25, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1 ], + "rightJoinKeys" : [ 0 ], + "rightUpsertKey" : [ 0, 1 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0, 1 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0, 1 ], + "lookupTableBinaryInputOrdinal" : 2, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 2 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + }, { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 1 + }, + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 0 ], + "left" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$AND$1", + "operands" : [ { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 1, + "type" : "DOUBLE NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 3, + "type" : "DOUBLE NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0, 1 ], + "rightJoinKey" : [ 2, 0 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 2, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = c1)], leftToRight=[Binary], rightToLeft=[[{round=[1], sourceTables=[default_catalog.default_database.srcC], lookupTable=[default_catalog.default_database.srcA], lookupKeys=[a1=c1]}, {round=[2], sourceTables=[default_catalog.default_database.srcA], lookupTable=[default_catalog.default_database.srcB], lookupKeys=[b1=a1, b0=a0]}]], select=[a1, a0, a2, b0, b2, b1, c1, c0, c2])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 26, + "type" : "stream-exec-sink_2", + "configuration" : { + "table.exec.sink.keyed-shuffle" : "AUTO", + "table.exec.sink.not-null-enforcer" : "ERROR", + "table.exec.sink.rowtime-inserter" : "ENABLED", + "table.exec.sink.type-length-enforcer" : "IGNORE", + "table.exec.sink.upsert-materialize" : "AUTO" + }, + "dynamicTableSink" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`snk`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a0_b0_c0_a1_b1_c1", + "type" : "PRIMARY_KEY", + "columns" : [ "a0", "b0", "c0", "a1", "b1", "c1" ] + } + } + } + } + }, + "inputChangelogMode" : [ "INSERT", "UPDATE_AFTER" ], + "inputUpsertKey" : [ 0, 1, 6, 7 ], + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Sink(table=[default_catalog.default_database.snk], fields=[a1, a0, a2, b0, b2, b1, c1, c0, c2])" + } ], + "edges" : [ { + "source" : 14, + "target" : 15, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 15, + "target" : 16, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 17, + "target" : 18, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 18, + "target" : 19, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 16, + "target" : 20, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 19, + "target" : 20, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 20, + "target" : 21, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 22, + "target" : 23, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 23, + "target" : 24, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 21, + "target" : 25, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 24, + "target" : 25, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 25, + "target" : 26, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + } ] +} \ No newline at end of file diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-contains-index/savepoint/_metadata b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-contains-index/savepoint/_metadata new file mode 100644 index 0000000000000000000000000000000000000000..0d37a63b87e2d4961000676404b1e59c8c68eaee GIT binary patch literal 26193 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 literal 0 HcmV?d00001 diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-equals-index/plan/cascaded-delta-join-with-join-key-equals-index.json b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-equals-index/plan/cascaded-delta-join-with-join-key-equals-index.json new file mode 100644 index 0000000000000..06c52b1804050 --- /dev/null +++ b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-equals-index/plan/cascaded-delta-join-with-join-key-equals-index.json @@ -0,0 +1,944 @@ +{ + "flinkVersion" : "2.3", + "nodes" : [ { + "id" : 1, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcA]], fields=[a1, a0, a2])" + }, { + "id" : 2, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 3, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 4, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcB]], fields=[b0, b2, b1])" + }, { + "id" : 5, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DropUpdateBefore" + }, { + "id" : 6, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 2 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[b1]])" + }, { + "id" : 7, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1 ], + "rightJoinKeys" : [ 2 ], + "rightUpsertKey" : [ 0, 2 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 1 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 2 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = b1)], leftToRight=[Binary], rightToLeft=[Binary], select=[a1, a0, a2, b0, b2, b1])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 8, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 9, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcC]], fields=[c1, c0, c2])" + }, { + "id" : 10, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 11, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[c1]])" + }, { + "id" : 12, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1, 3, 5 ], + "rightJoinKeys" : [ 0 ], + "rightUpsertKey" : [ 0, 1 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0, 1 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0, 1 ], + "lookupTableBinaryInputOrdinal" : 2, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 2 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + }, { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 6, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 0 ], + "left" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 2, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = c1)], leftToRight=[Binary], rightToLeft=[[{round=[1], sourceTables=[default_catalog.default_database.srcC], lookupTable=[default_catalog.default_database.srcA], lookupKeys=[a1=c1]}, {round=[2], sourceTables=[default_catalog.default_database.srcA], lookupTable=[default_catalog.default_database.srcB], lookupKeys=[b1=a1]}]], select=[a1, a0, a2, b0, b2, b1, c1, c0, c2])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 13, + "type" : "stream-exec-sink_2", + "configuration" : { + "table.exec.sink.keyed-shuffle" : "AUTO", + "table.exec.sink.not-null-enforcer" : "ERROR", + "table.exec.sink.rowtime-inserter" : "ENABLED", + "table.exec.sink.type-length-enforcer" : "IGNORE", + "table.exec.sink.upsert-materialize" : "AUTO" + }, + "dynamicTableSink" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`snk`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a0_b0_c0_a1_b1_c1", + "type" : "PRIMARY_KEY", + "columns" : [ "a0", "b0", "c0", "a1", "b1", "c1" ] + } + } + } + } + }, + "inputChangelogMode" : [ "INSERT", "UPDATE_AFTER" ], + "upsertMaterializeStrategy" : "ADAPTIVE", + "inputUpsertKey" : [ 0, 1, 3, 5, 6, 7 ], + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Sink(table=[default_catalog.default_database.snk], fields=[a1, a0, a2, b0, b2, b1, c1, c0, c2])" + } ], + "edges" : [ { + "source" : 1, + "target" : 2, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 2, + "target" : 3, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 4, + "target" : 5, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 5, + "target" : 6, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 3, + "target" : 7, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 6, + "target" : 7, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 7, + "target" : 8, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 9, + "target" : 10, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 10, + "target" : 11, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 8, + "target" : 12, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 11, + "target" : 12, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 12, + "target" : 13, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + } ] +} \ No newline at end of file diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-equals-index/savepoint/_metadata b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-join-key-equals-index/savepoint/_metadata new file mode 100644 index 0000000000000000000000000000000000000000..8c5972a2f8e5e61547c98f4a911627dab22a5b4e GIT binary patch literal 25668 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", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcA]], fields=[a1, a0, a2])" + }, { + "id" : 28, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 29, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 30, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcB]], fields=[b0, b2, b1])" + }, { + "id" : 31, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DropUpdateBefore" + }, { + "id" : 32, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 2 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[b1]])" + }, { + "id" : 33, + "type" : "stream-exec-delta-join_2", + "configuration" : { + "table.exec.async-lookup.buffer-capacity" : "100", + "table.exec.async-lookup.timeout" : "3 min" + }, + "joinType" : "INNER", + "leftJoinKeys" : [ 0 ], + "leftUpsertKey" : [ 0, 1 ], + "rightJoinKeys" : [ 2 ], + "rightUpsertKey" : [ 0, 2 ], + "lookupRightTableJoinSpec" : null, + "lookupLeftTableJoinSpec" : null, + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "leftAllBinaryInputOrdinals" : [ 0 ], + "rightAllBinaryInputOrdinals" : [ 0 ], + "left2RightLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 0 ], + "lookupTableBinaryInputOrdinal" : 1, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + }, + "lookupKeys" : { + "2" : { + "type" : "FieldRef", + "index" : 0 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "right2LeftLookupChain" : { + "nodes" : [ { + "inputTableBinaryInputOrdinals" : [ 1 ], + "lookupTableBinaryInputOrdinal" : 0, + "deltaJoinSpec" : { + "lookupTable" : { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, + "lookupKeys" : { + "0" : { + "type" : "FieldRef", + "index" : 2 + } + }, + "remainingCondition" : null + }, + "joinType" : "INNER" + } ] + }, + "allBinaryInputTables" : [ { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcA`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a1_a0", + "type" : "PRIMARY_KEY", + "columns" : [ "a1", "a0" ] + }, + "indexes" : [ { + "name" : "INDEX_a1", + "columns" : [ "a1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)> NOT NULL" + }, { + "lookupTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcB`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + } ], + "primaryKey" : { + "name" : "PK_b0_b1", + "type" : "PRIMARY_KEY", + "columns" : [ "b0", "b1" ] + }, + "indexes" : [ { + "name" : "INDEX_b1", + "columns" : [ "b1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL> NOT NULL" + } ], + "deltaJoinTree" : { + "root" : { + "type" : "JoinNode", + "joinType" : "INNER", + "condition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$=$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 0, + "type" : "INT NOT NULL" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 5, + "type" : "INT NOT NULL" + } ], + "type" : "BOOLEAN NOT NULL" + }, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "leftJoinKey" : [ 0 ], + "rightJoinKey" : [ 2 ], + "left" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 0, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647)>" + }, + "right" : { + "type" : "BinaryInputNode", + "inputOrdinal" : 1, + "projection" : null, + "filter" : null, + "rowTypeAfterCalc" : null, + "rowType" : "ROW<`b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>" + } + } + }, + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "DeltaJoin(joinType=[InnerJoin], where=[(a1 = b1)], leftToRight=[Binary], rightToLeft=[Binary], select=[a1, a0, a2, b0, b2, b1])", + "asyncOptions" : { + "capacity " : 100, + "timeout" : 180000, + "is-key-ordered" : true, + "output-mode" : "ORDERED" + } + }, { + "id" : 34, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL>", + "description" : "Exchange(distribution=[hash[a1]])" + }, { + "id" : 35, + "type" : "stream-exec-table-source-scan_2", + "scanTableSource" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`srcC`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_c1_c0", + "type" : "PRIMARY_KEY", + "columns" : [ "c1", "c0" ] + }, + "indexes" : [ { + "name" : "INDEX_c1", + "columns" : [ "c1" ] + } ] + } + } + } + }, + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "TableSourceScan(table=[[default_catalog, default_database, srcC]], fields=[c1, c0, c2])" + }, { + "id" : 36, + "type" : "stream-exec-drop-update-before_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "DropUpdateBefore" + }, { + "id" : 37, + "type" : "stream-exec-exchange_1", + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "HASH", + "keys" : [ 0 ] + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Exchange(distribution=[hash[c1]])" + }, { + "id" : 38, + "type" : "stream-exec-join_1", + "joinSpec" : { + "joinType" : "INNER", + "leftKeys" : [ 0 ], + "rightKeys" : [ 0 ], + "filterNulls" : [ true ], + "nonEquiCondition" : { + "kind" : "CALL", + "syntax" : "BINARY", + "internalName" : "$<>$1", + "operands" : [ { + "kind" : "INPUT_REF", + "inputIndex" : 2, + "type" : "VARCHAR(2147483647)" + }, { + "kind" : "INPUT_REF", + "inputIndex" : 8, + "type" : "VARCHAR(2147483647)" + } ], + "type" : "BOOLEAN" + } + }, + "leftUpsertKeys" : [ [ 0, 1, 3, 5 ] ], + "rightUpsertKeys" : [ [ 0, 1 ] ], + "state" : [ { + "index" : 0, + "ttl" : "0 ms", + "name" : "leftState" + }, { + "index" : 1, + "ttl" : "0 ms", + "name" : "rightState" + } ], + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + }, { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Join(joinType=[InnerJoin], where=[((a1 = c1) AND (a2 <> c2))], select=[a1, a0, a2, b0, b2, b1, c1, c0, c2], leftInputSpec=[HasUniqueKey], rightInputSpec=[HasUniqueKey])" + }, { + "id" : 39, + "type" : "stream-exec-sink_2", + "configuration" : { + "table.exec.sink.keyed-shuffle" : "AUTO", + "table.exec.sink.not-null-enforcer" : "ERROR", + "table.exec.sink.rowtime-inserter" : "ENABLED", + "table.exec.sink.type-length-enforcer" : "IGNORE", + "table.exec.sink.upsert-materialize" : "AUTO" + }, + "dynamicTableSink" : { + "table" : { + "identifier" : "`default_catalog`.`default_database`.`snk`", + "resolvedTable" : { + "schema" : { + "columns" : [ { + "name" : "a1", + "dataType" : "INT NOT NULL" + }, { + "name" : "a0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "a2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "b2", + "dataType" : "VARCHAR(2147483647)" + }, { + "name" : "b1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c1", + "dataType" : "INT NOT NULL" + }, { + "name" : "c0", + "dataType" : "DOUBLE NOT NULL" + }, { + "name" : "c2", + "dataType" : "VARCHAR(2147483647)" + } ], + "primaryKey" : { + "name" : "PK_a0_b0_c0_a1_b1_c1", + "type" : "PRIMARY_KEY", + "columns" : [ "a0", "b0", "c0", "a1", "b1", "c1" ] + } + } + } + } + }, + "inputChangelogMode" : [ "INSERT", "UPDATE_AFTER" ], + "upsertMaterializeStrategy" : "VALUE", + "inputUpsertKey" : [ 0, 1, 3, 5, 6, 7 ], + "inputProperties" : [ { + "requiredDistribution" : { + "type" : "UNKNOWN" + }, + "damBehavior" : "PIPELINED", + "priority" : 0 + } ], + "outputType" : "ROW<`a1` INT NOT NULL, `a0` DOUBLE NOT NULL, `a2` VARCHAR(2147483647), `b0` DOUBLE NOT NULL, `b2` VARCHAR(2147483647), `b1` INT NOT NULL, `c1` INT NOT NULL, `c0` DOUBLE NOT NULL, `c2` VARCHAR(2147483647)>", + "description" : "Sink(table=[default_catalog.default_database.snk], fields=[a1, a0, a2, b0, b2, b1, c1, c0, c2])" + } ], + "edges" : [ { + "source" : 27, + "target" : 28, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 28, + "target" : 29, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 30, + "target" : 31, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 31, + "target" : 32, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 29, + "target" : 33, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 32, + "target" : 33, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 33, + "target" : 34, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 35, + "target" : 36, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 36, + "target" : 37, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 34, + "target" : 38, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 37, + "target" : 38, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + }, { + "source" : 38, + "target" : 39, + "shuffle" : { + "type" : "FORWARD" + }, + "shuffleMode" : "PIPELINED" + } ] +} \ No newline at end of file diff --git a/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-non-equiv-condition/savepoint/_metadata b/flink-table/flink-table-planner/src/test/resources/restore-tests/stream-exec-delta-join_2/cascaded-delta-join-with-non-equiv-condition/savepoint/_metadata new file mode 100644 index 0000000000000000000000000000000000000000..8abd813ee51278caf94e8b47afb1a7b920b0c381 GIT binary patch literal 26141 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 literal 0 HcmV?d00001