You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by sn...@apache.org on 2025/12/04 21:48:41 UTC
(flink) branch master updated (c4d6344ab8e -> 11f61d23b80)
This is an automated email from the ASF dual-hosted git repository.
snuyanzin pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/flink.git
from c4d6344ab8e [FLINK-38403][tests] Fix the unexpected test that the second job does not restore from checkpoint (#27254)
new fc85065a1c0 [FLINK-38766][table] Add support for `ALTER MATERIALIZED TABLE ADD` support
new 11f61d23b80 [FLINK-38766][table] Migrate `TableEnvironmentTest` to assertJ
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../src/test/resources/sql/table.q | 2 +-
.../MaterializedTableManager.java | 71 +-
.../service/MaterializedTableStatementITCase.java | 865 +++++---------
.../src/main/codegen/includes/parserImpls.ftl | 8 +-
.../ddl/SqlAlterMaterializedTableSchema.java | 8 +-
.../AlterMaterializedTableAsQueryOperation.java | 4 +-
.../AlterMaterializedTableChangeOperation.java | 13 +-
.../catalog/CatalogBaseTableResolutionTest.java | 15 +-
.../flink/table/catalog/CatalogPropertiesUtil.java | 15 +-
.../table/catalog/CatalogPropertiesUtilTest.java | 9 +-
.../AbstractAlterMaterializedTableConverter.java | 53 +-
.../AbstractCreateMaterializedTableConverter.java | 7 +-
.../operations/converters/SchemaAddConverter.java | 33 +-
.../operations/converters/SchemaConverter.java | 48 +-
.../converters/SchemaModifyConverter.java | 38 +-
...rMaterializedTableAddDistributionConverter.java | 48 +-
.../SqlAlterMaterializedTableAsQueryConverter.java | 22 +-
...MaterializedTableDropDistributionConverter.java | 15 +-
...terializedTableModifyDistributionConverter.java | 18 +-
.../SqlAlterMaterializedTableSchemaConverter.java | 70 ++
...SqlCreateOrAlterMaterializedTableConverter.java | 53 +-
.../operations/converters/SqlNodeConverters.java | 2 +
.../table/AbstractAlterTableConverter.java | 4 +-
.../converters/table/MergeTableAsUtil.java | 65 +-
.../SqlAlterTableAddDistributionConverter.java | 2 +-
.../table/SqlAlterTableSchemaAddConverter.java | 5 +-
.../table/SqlAlterTableSchemaConverter.java | 6 +-
.../table/SqlAlterTableSchemaModifyConverter.java | 5 +-
.../planner/utils/MaterializedTableUtils.java | 70 ++
.../operations/SqlDdlToOperationConverterTest.java | 25 +-
...erializedTableNodeToOperationConverterTest.java | 724 ++++++------
.../flink/table/api/TableEnvironmentTest.scala | 1215 ++++++++++----------
.../catalog/TestFileSystemCatalogTest.java | 25 +-
33 files changed, 1679 insertions(+), 1884 deletions(-)
create mode 100644 flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableSchemaConverter.java
(flink) 02/02: [FLINK-38766][table] Migrate `TableEnvironmentTest` to assertJ
Posted by sn...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
snuyanzin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/flink.git
commit 11f61d23b80ba639922e43830667eb2010fffdfb
Author: Sergey Nuyanzin <sn...@gmail.com>
AuthorDate: Wed Dec 3 15:15:24 2025 +0100
[FLINK-38766][table] Migrate `TableEnvironmentTest` to assertJ
---
.../flink/table/api/TableEnvironmentTest.scala | 1207 ++++++++++----------
1 file changed, 592 insertions(+), 615 deletions(-)
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/api/TableEnvironmentTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/api/TableEnvironmentTest.scala
index 30b36f1f476..225843946f1 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/api/TableEnvironmentTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/api/TableEnvironmentTest.scala
@@ -46,8 +46,7 @@ import _root_.java.util
import _root_.scala.collection.JavaConverters._
import org.apache.calcite.plan.RelOptUtil
import org.apache.calcite.sql.SqlExplainLevel
-import org.assertj.core.api.Assertions.{assertThat, assertThatThrownBy}
-import org.junit.jupiter.api.Assertions.{assertEquals, assertFalse, assertTrue, fail}
+import org.assertj.core.api.Assertions.{assertThat, assertThatExceptionOfType, assertThatList, assertThatObject}
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.io.TempDir
import org.junit.jupiter.params.ParameterizedTest
@@ -68,9 +67,9 @@ class TableEnvironmentTest {
@Test
def testScanNonExistTable(): Unit = {
- assertThatThrownBy(() => tableEnv.from("MyTable"))
- .hasMessageContaining("Table `MyTable` was not found")
- .isInstanceOf[ValidationException]
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.from("MyTable"))
+ .withMessageContaining("Table `MyTable` was not found")
}
@Test
@@ -83,17 +82,17 @@ class TableEnvironmentTest {
val relNode = TableTestUtil.toRelNode(scanTable)
val actual = RelOptUtil.toString(relNode)
val expected = "LogicalTableScan(table=[[default_catalog, default_database, MyTable]])\n"
- assertEquals(expected, actual)
-
- assertThatThrownBy(
- () =>
- tableEnv.createTemporaryView(
- "MyTable",
- StreamingEnvUtil
- .fromElements[(Int, Long)](env)))
- .hasMessageContaining(
+ assertThat(actual).isEqualTo(expected)
+
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(
+ () =>
+ tableEnv.createTemporaryView(
+ "MyTable",
+ StreamingEnvUtil
+ .fromElements[(Int, Long)](env)))
+ .withMessageContaining(
"Temporary table '`default_catalog`.`default_database`.`MyTable`' already exists")
- .isInstanceOf[ValidationException]
}
@Test
@@ -107,39 +106,39 @@ class TableEnvironmentTest {
val actual = RelOptUtil.toString(relNode, SqlExplainLevel.NO_ATTRIBUTES)
val expected = "LogicalProject\n" +
" LogicalTableScan\n"
- assertEquals(expected, actual)
+ assertThat(actual).isEqualTo(expected)
}
@Test
def testCreateTableWithEnforcedMode(): Unit = {
// check column constraint
- assertThatThrownBy(() => tableEnv.executeSql("""
- |CREATE TABLE MyTable (
- | a bigint primary key,
- | b int,
- | c varchar
- |) with (
- | 'connector' = 'COLLECTION',
- | 'is-bounded' = 'false'
- |)
+ assertThatExceptionOfType(classOf[SqlValidateException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |CREATE TABLE MyTable (
+ | a bigint primary key,
+ | b int,
+ | c varchar
+ |) with (
+ | 'connector' = 'COLLECTION',
+ | 'is-bounded' = 'false'
+ |)
""".stripMargin))
- .hasMessageContaining("Flink doesn't support ENFORCED mode for PRIMARY KEY constraint.")
- .isInstanceOf[ValidationException]
+ .withMessageContaining("Flink doesn't support ENFORCED mode for PRIMARY KEY constraint.")
// check table constraint
- assertThatThrownBy(() => tableEnv.executeSql("""
- |CREATE TABLE MyTable (
- | a bigint,
- | b int,
- | c varchar,
- | primary key(a)
- |) with (
- | 'connector' = 'COLLECTION',
- | 'is-bounded' = 'false'
- |)
+ assertThatExceptionOfType(classOf[SqlValidateException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |CREATE TABLE MyTable (
+ | a bigint,
+ | b int,
+ | c varchar,
+ | primary key(a)
+ |) with (
+ | 'connector' = 'COLLECTION',
+ | 'is-bounded' = 'false'
+ |)
""".stripMargin))
- .hasMessageContaining("Flink doesn't support ENFORCED mode for PRIMARY KEY constraint.")
- .isInstanceOf[ValidationException]
+ .withMessageContaining("Flink doesn't support ENFORCED mode for PRIMARY KEY constraint.")
}
@Test
@@ -158,7 +157,8 @@ class TableEnvironmentTest {
val expected = TableTestUtil.readFromResource("/explain/testStreamTableEnvironmentExplain.out")
val actual = tEnv.explainSql("insert into MySink select first from MyTable")
- assertEquals(TableTestUtil.replaceStageId(expected), TableTestUtil.replaceStageId(actual))
+ assertThat(TableTestUtil.replaceStageId(actual))
+ .isEqualTo(TableTestUtil.replaceStageId(expected))
}
@Test
@@ -177,7 +177,8 @@ class TableEnvironmentTest {
val expected = TableTestUtil.readFromResource("/explain/testStreamTableEnvironmentExplain.out")
val actual = tEnv.explainSql("execute insert into MySink select first from MyTable")
- assertEquals(TableTestUtil.replaceStageId(expected), TableTestUtil.replaceStageId(actual))
+ assertThat(TableTestUtil.replaceStageId(actual))
+ .isEqualTo(TableTestUtil.replaceStageId(expected))
}
@Test
@@ -214,12 +215,8 @@ class TableEnvironmentTest {
@Test
def testAddIllegalJar(): Unit = {
- try {
- tableEnv.executeSql(String.format("ADD JAR '%s'", "/path/to/illegal.jar"))
- fail("Should fail.")
- } catch {
- case _: TableException => // expected
- }
+ assertThatExceptionOfType(classOf[TableException])
+ .isThrownBy(() => tableEnv.executeSql(String.format("ADD JAR '%s'", "/path/to/illegal.jar")))
}
private def validateAddJar(useFullPath: Boolean): Unit = {
@@ -240,7 +237,7 @@ class TableEnvironmentTest {
tableEnv.executeSql(String.format("ADD JAR '%s'", jarPath))
val tableResult = tableEnv.executeSql("SHOW JARS")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(util.Arrays.asList(Row.of(udfJar.getPath)).iterator(), tableResult.collect())
}
@@ -259,10 +256,10 @@ class TableEnvironmentTest {
"insert into MySink select first from MyTable",
ExplainDetail.JSON_EXECUTION_PLAN)
- assertEquals(
- TableTestUtil.replaceNodeIdInOperator(TableTestUtil.replaceStreamNodeId(expected)),
- TableTestUtil.replaceNodeIdInOperator(TableTestUtil.replaceStreamNodeId(actual))
- )
+ assertThat(TableTestUtil.replaceNodeIdInOperator(TableTestUtil.replaceStreamNodeId(actual)))
+ .isEqualTo(
+ TableTestUtil.replaceNodeIdInOperator(TableTestUtil.replaceStreamNodeId(expected))
+ )
}
@Test
@@ -316,10 +313,10 @@ class TableEnvironmentTest {
ExplainDetail.JSON_EXECUTION_PLAN
)
- assertEquals(
- TableTestUtil.replaceNodeIdInOperator(TableTestUtil.replaceStreamNodeId(expected)),
- TableTestUtil.replaceNodeIdInOperator(TableTestUtil.replaceStreamNodeId(actual))
- )
+ assertThat(TableTestUtil.replaceNodeIdInOperator(TableTestUtil.replaceStreamNodeId(actual)))
+ .isEqualTo(
+ TableTestUtil.replaceNodeIdInOperator(TableTestUtil.replaceStreamNodeId(expected))
+ )
}
@Test
@@ -335,9 +332,9 @@ class TableEnvironmentTest {
|)
""".stripMargin
tableEnv.executeSql(statement)
- assertThatThrownBy(() => tableEnv.executeSql("ALTER TABLE MyTable RESET ()"))
- .hasMessageContaining("ALTER TABLE RESET does not support empty key")
- .isInstanceOf[ValidationException]
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("ALTER TABLE MyTable RESET ()"))
+ .withMessageContaining("ALTER TABLE RESET does not support empty key")
}
@Test
@@ -355,9 +352,9 @@ class TableEnvironmentTest {
|)
""".stripMargin
tableEnv.executeSql(statementWithTypo)
- assertThatThrownBy(
- () => tableEnv.executeSql("explain plan for select * from MyTable where a > 10"))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("explain plan for select * from MyTable where a > 10"))
+ .withMessageContaining(
"Unable to create a source for reading table " +
"'default_catalog.default_database.MyTable'.\n\n" +
"Table options are:\n\n'connector'='datagen'\n" +
@@ -366,18 +363,17 @@ class TableEnvironmentTest {
// remove invalid key by RESET
val alterTableResetStatement = "ALTER TABLE MyTable RESET ('invalid-key')"
val tableResult = tableEnv.executeSql(alterTableResetStatement)
- assertEquals(ResultKind.SUCCESS, tableResult.getResultKind)
- assertEquals(
- Map("connector" -> "datagen").asJava,
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
.getTable(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.MyTable"))
.getOptions
- )
- assertEquals(
- ResultKind.SUCCESS_WITH_CONTENT,
+ ).containsAllEntriesOf(util.Map.of("connector", "datagen"))
+ assertThatObject(
tableEnv.executeSql("explain plan for select * from MyTable where a > 10").getResultKind)
+ .isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
}
@Test
@@ -398,15 +394,14 @@ class TableEnvironmentTest {
val alterTableResetStatement = "ALTER TABLE MyTable RESET ('is-bounded')"
val tableResult = tableEnv.executeSql(alterTableResetStatement)
- assertEquals(ResultKind.SUCCESS, tableResult.getResultKind)
- assertEquals(
- Map.apply("connector" -> "COLLECTION").asJava,
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
.getTable(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.MyTable"))
.getOptions
- )
+ ).containsAllEntriesOf(util.Map.of("connector", "COLLECTION"))
checkTableSource("MyTable", true)
}
@@ -428,22 +423,19 @@ class TableEnvironmentTest {
val alterTableResetStatement = "ALTER TABLE MyTable RESET ('format')"
val tableResult = tableEnv.executeSql(alterTableResetStatement)
- assertEquals(ResultKind.SUCCESS, tableResult.getResultKind)
- assertEquals(
- Map("connector" -> "filesystem", "path" -> "_invalid").asJava,
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
.getTable(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.MyTable"))
.getOptions
- )
+ ).containsAllEntriesOf(util.Map.of("connector", "filesystem", "path", "_invalid"))
- assertThatThrownBy(
- () =>
- tableEnv.executeSql("explain plan for select * from MyTable where a > 10").getResultKind)
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("explain plan for select * from MyTable where a > 10"))
+ .withMessageContaining(
"Unable to create a source for reading table 'default_catalog.default_database.MyTable'.")
- .isInstanceOf[ValidationException]
}
@Test
@@ -462,35 +454,35 @@ class TableEnvironmentTest {
""".stripMargin
tableEnv.executeSql(statement)
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable ADD (
- | PRIMARY KEY (a) NOT ENFORCED
- |)
- |""".stripMargin))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable ADD (
+ | PRIMARY KEY (a) NOT ENFORCED
+ |)
+ |""".stripMargin))
+ .withMessageContaining(
"""Failed to execute ALTER TABLE statement.
|The current table has already defined the primary key constraint [`b`]. You might want to drop it before adding a new one.""".stripMargin)
- .isInstanceOf[ValidationException]
-
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable ADD (
- | a STRING
- |)
- |""".stripMargin))
- .hasMessageContaining("""Failed to execute ALTER TABLE statement.
- |Column `a` already exists in the table.""".stripMargin)
- .isInstanceOf[ValidationException]
-
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable ADD (
- | e STRING AFTER h
- |)
- |""".stripMargin))
- .hasMessageContaining(
+
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable ADD (
+ | a STRING
+ |)
+ |""".stripMargin))
+ .withMessageContaining("""Failed to execute ALTER TABLE statement.
+ |Column `a` already exists in the table.""".stripMargin)
+
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable ADD (
+ | e STRING AFTER h
+ |)
+ |""".stripMargin))
+ .withMessageContaining(
"""Failed to execute ALTER TABLE statement.
|Referenced column `h` by 'AFTER' does not exist in the table.""".stripMargin
)
- .isInstanceOf[ValidationException]
tableEnv.executeSql(
"""
@@ -537,14 +529,14 @@ class TableEnvironmentTest {
Row.of("g", "ARRAY<INT NOT NULL>", Boolean.box(false), null, null, null, null)
)
val tableResult = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult.iterator(), tableResult.collect())
- assertThatThrownBy(() => tableEnv.executeSql("ALTER TABLE MyTable ADD WATERMARK FOR ts AS ts"))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("ALTER TABLE MyTable ADD WATERMARK FOR ts AS ts"))
+ .withMessageContaining(
"""Failed to execute ALTER TABLE statement.
|The current table has already defined the watermark strategy `d` AS `d` - INTERVAL '2' SECOND. You might want to drop it before adding a new one.""".stripMargin)
- .isInstanceOf[ValidationException]
}
@Test
@@ -563,24 +555,24 @@ class TableEnvironmentTest {
""".stripMargin
tableEnv.executeSql(statement)
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable ADD (
- | f STRING PRIMARY KEY NOT ENFORCED,
- | PRIMARY KEY (a) NOT ENFORCED
- |)
- |""".stripMargin))
- .hasMessageContaining("Duplicate primary key definition")
- .isInstanceOf[org.apache.flink.sql.parser.error.SqlValidateException]
-
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable ADD (
- | PRIMARY KEY (c) NOT ENFORCED
- |)
- |""".stripMargin))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[SqlValidateException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable ADD (
+ | f STRING PRIMARY KEY NOT ENFORCED,
+ | PRIMARY KEY (a) NOT ENFORCED
+ |)
+ |""".stripMargin))
+ .withMessageContaining("Duplicate primary key definition")
+
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable ADD (
+ | PRIMARY KEY (c) NOT ENFORCED
+ |)
+ |""".stripMargin))
+ .withMessageContaining(
"""Failed to execute ALTER TABLE statement.
|Invalid primary key 'PK_c'. Column 'c' is not a physical column.""".stripMargin)
- .isInstanceOf[ValidationException]
tableEnv.executeSql("""
|ALTER TABLE MyTable ADD (
@@ -595,7 +587,7 @@ class TableEnvironmentTest {
Row.of("d", "TIMESTAMP(3)", Boolean.box(true), null, null, null)
)
val tableResult = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult.iterator(), tableResult.collect())
}
@@ -616,15 +608,15 @@ class TableEnvironmentTest {
""".stripMargin
tableEnv.executeSql(statement)
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable ADD (
- | WATERMARK FOR e.e1 AS e.e1
- |)
- |""".stripMargin))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable ADD (
+ | WATERMARK FOR e.e1 AS e.e1
+ |)
+ |""".stripMargin))
+ .withMessageContaining(
"""Failed to execute ALTER TABLE statement.
|Watermark strategy on nested column is not supported yet.""".stripMargin)
- .isInstanceOf[ValidationException]
tableEnv.executeSql("""
|ALTER TABLE MyTable ADD (
@@ -640,7 +632,7 @@ class TableEnvironmentTest {
Row.of("e", "ROW<`e0` STRING, `e1` TIMESTAMP(3)>", Boolean.box(true), null, null, null)
)
val tableResult = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult.iterator(), tableResult.collect())
}
@@ -665,34 +657,34 @@ class TableEnvironmentTest {
""".stripMargin
tableEnv.executeSql(statement)
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable MODIFY (
- | x STRING FIRST
- |)
- |""".stripMargin))
- .hasMessageContaining("""Failed to execute ALTER TABLE statement.
- |Column `x` does not exist in the table.""".stripMargin)
- .isInstanceOf[ValidationException]
-
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable MODIFY (
- | b INT FIRST,
- | a BIGINT AFTER x
- |)
- |""".stripMargin))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable MODIFY (
+ | x STRING FIRST
+ |)
+ |""".stripMargin))
+ .withMessageContaining("""Failed to execute ALTER TABLE statement.
+ |Column `x` does not exist in the table.""".stripMargin)
+
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable MODIFY (
+ | b INT FIRST,
+ | a BIGINT AFTER x
+ |)
+ |""".stripMargin))
+ .withMessageContaining(
"""Failed to execute ALTER TABLE statement.
|Referenced column `x` by 'AFTER' does not exist in the table.""".stripMargin)
- .isInstanceOf[ValidationException]
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable MODIFY (
- | b BOOLEAN first
- |)
- |""".stripMargin))
- .hasMessageContaining("""Failed to execute ALTER TABLE statement.
- |Invalid expression for computed column 'e'.""".stripMargin)
- .isInstanceOf[ValidationException]
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable MODIFY (
+ | b BOOLEAN first
+ |)
+ |""".stripMargin))
+ .withMessageContaining("""Failed to execute ALTER TABLE statement.
+ |Invalid expression for computed column 'e'.""".stripMargin)
tableEnv.executeSql("""
|ALTER TABLE MyTable MODIFY (
@@ -716,7 +708,7 @@ class TableEnvironmentTest {
"`ts2` - INTERVAL '1' SECOND")
)
val tableResult1 = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), tableResult1.collect())
tableEnv.executeSql("""
@@ -738,7 +730,7 @@ class TableEnvironmentTest {
Row.of("a", "DOUBLE", Boolean.box(false), null, null, null)
)
val tableResult = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult2.iterator(), tableResult.collect())
}
@@ -757,15 +749,15 @@ class TableEnvironmentTest {
""".stripMargin
tableEnv.executeSql(statement)
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable MODIFY (
- | PRIMARY KEY (x) NOT ENFORCED
- |)
- |""".stripMargin))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable MODIFY (
+ | PRIMARY KEY (x) NOT ENFORCED
+ |)
+ |""".stripMargin))
+ .withMessageContaining(
"""Failed to execute ALTER TABLE statement.
|The current table does not define any primary key constraint. You might want to add a new one.""".stripMargin)
- .isInstanceOf[ValidationException]
tableEnv.executeSql("""
|ALTER TABLE MyTable ADD (
@@ -784,7 +776,7 @@ class TableEnvironmentTest {
Row.of("c", "STRING", Boolean.box(true), null, "METADATA VIRTUAL", null)
)
val tableResult = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult.iterator(), tableResult.collect())
}
@@ -805,15 +797,15 @@ class TableEnvironmentTest {
""".stripMargin
tableEnv.executeSql(statement)
- assertThatThrownBy(() => tableEnv.executeSql("""
- |ALTER TABLE MyTable MODIFY (
- | WATERMARK FOR e.e1 AS e.e1
- |)
- |""".stripMargin))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("""
+ |ALTER TABLE MyTable MODIFY (
+ | WATERMARK FOR e.e1 AS e.e1
+ |)
+ |""".stripMargin))
+ .withMessageContaining(
"""Failed to execute ALTER TABLE statement.
|Watermark strategy on nested column is not supported yet.""".stripMargin)
- .isInstanceOf[ValidationException]
tableEnv.executeSql("""
|ALTER TABLE MyTable MODIFY (
@@ -828,7 +820,7 @@ class TableEnvironmentTest {
Row.of("e", "ROW<`e0` STRING, `e1` TIMESTAMP(3)>", Boolean.box(true), null, null, null)
)
val tableResult = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult.iterator(), tableResult.collect())
}
@@ -846,7 +838,7 @@ class TableEnvironmentTest {
|ALTER TABLE MyTable RENAME a TO b
|""".stripMargin)
val tableResult = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(
Collections
.singletonList(Row.of("b", "BIGINT", Boolean.box(true), null, null, null))
@@ -884,7 +876,7 @@ class TableEnvironmentTest {
"`d` - INTERVAL '1' MINUTE")
)
val tableResult = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult.iterator(), tableResult.collect())
}
@@ -914,13 +906,13 @@ class TableEnvironmentTest {
Row.of("e", "ROW<`e0` STRING, `e1` TIMESTAMP(3)>", Boolean.box(true), null, null, null)
)
val tableResult1 = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult.iterator(), tableResult1.collect())
tableEnv.executeSql("ALTER TABLE MyTable ADD CONSTRAINT ct PRIMARY KEY(a) NOT ENFORCED")
tableEnv.executeSql("ALTER TABLE MyTable DROP PRIMARY KEY")
val tableResult2 = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult.iterator(), tableResult2.collect())
}
@@ -950,7 +942,7 @@ class TableEnvironmentTest {
Row.of("e", "ROW<`e0` STRING, `e1` TIMESTAMP(3)>", Boolean.box(true), null, null, null)
)
val tableResult = tableEnv.executeSql("DESCRIBE MyTable")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult.iterator(), tableResult.collect())
}
@@ -988,23 +980,23 @@ class TableEnvironmentTest {
// drop the partitions
var tableResult =
tableEnv.executeSql("alter table tbl drop partition(b='1000', c ='2020-05-01')")
- assertEquals(ResultKind.SUCCESS, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS)
assertThat(catalog.listPartitions(tablePath).toString)
.isEqualTo("[CatalogPartitionSpec{{b=2000, c=2020-01-01}}]")
// drop the partition again with if exists
tableResult =
tableEnv.executeSql("alter table tbl drop if exists partition(b='1000', c='2020-05-01')")
- assertEquals(ResultKind.SUCCESS, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS)
assertThat(catalog.listPartitions(tablePath).toString)
.isEqualTo("[CatalogPartitionSpec{{b=2000, c=2020-01-01}}]")
// drop the partition again without if exists,
// should throw exception then
- assertThatThrownBy(
- () => tableEnv.executeSql("alter table tbl drop partition (b=1000,c='2020-05-01')"))
- .isInstanceOf(classOf[TableException])
- .hasMessageContaining("Could not execute ALTER TABLE default_catalog.default_database.tbl" +
+ assertThatExceptionOfType(classOf[TableException])
+ .isThrownBy(
+ () => tableEnv.executeSql("alter table tbl drop partition (b=1000,c='2020-05-01')"))
+ .withMessageContaining("Could not execute ALTER TABLE default_catalog.default_database.tbl" +
" DROP PARTITION (b=1000, c=2020-05-01)")
}
@@ -1023,28 +1015,28 @@ class TableEnvironmentTest {
tableEnv.executeSql(statement)
tableEnv.executeSql("CREATE TEMPORARY VIEW my_view AS SELECT a, c FROM MyTable")
- assertThatThrownBy(
- () => tableEnv.executeSql("SELECT c FROM my_view /*+ OPTIONS('is-bounded' = 'true') */"))
- .hasMessageContaining("View '`default_catalog`.`default_database`.`my_view`' " +
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(
+ () => tableEnv.executeSql("SELECT c FROM my_view /*+ OPTIONS('is-bounded' = 'true') */"))
+ .withMessageContaining("View '`default_catalog`.`default_database`.`my_view`' " +
"cannot be enriched with new options. Hints can only be applied to tables.")
- .isInstanceOf(classOf[ValidationException])
-
- assertThatThrownBy(
- () =>
- tableEnv.executeSql(
- "CREATE TEMPORARY VIEW your_view AS " +
- "SELECT c FROM my_view /*+ OPTIONS('is-bounded' = 'true') */"))
- .hasMessageContaining("View '`default_catalog`.`default_database`.`my_view`' " +
+
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(
+ () =>
+ tableEnv.executeSql(
+ "CREATE TEMPORARY VIEW your_view AS " +
+ "SELECT c FROM my_view /*+ OPTIONS('is-bounded' = 'true') */"))
+ .withMessageContaining("View '`default_catalog`.`default_database`.`my_view`' " +
"cannot be enriched with new options. Hints can only be applied to tables.")
- .isInstanceOf(classOf[ValidationException])
tableEnv.executeSql("CREATE TEMPORARY VIEW your_view AS SELECT c FROM my_view ")
- assertThatThrownBy(
- () => tableEnv.executeSql("SELECT * FROM your_view /*+ OPTIONS('is-bounded' = 'true') */"))
- .hasMessageContaining("View '`default_catalog`.`default_database`.`your_view`' " +
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(
+ () => tableEnv.executeSql("SELECT * FROM your_view /*+ OPTIONS('is-bounded' = 'true') */"))
+ .withMessageContaining("View '`default_catalog`.`default_database`.`your_view`' " +
"cannot be enriched with new options. Hints can only be applied to tables.")
- .isInstanceOf(classOf[ValidationException])
}
@@ -1052,30 +1044,30 @@ class TableEnvironmentTest {
def testExecuteSqlWithCreateAlterDropTable(): Unit = {
createTableForTests()
- assertTrue(
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
- .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.T1")))
+ .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.T1"))).isTrue
val tableResult2 = tableEnv.executeSql("ALTER TABLE T1 SET ('k1' = 'a', 'k2' = 'b')")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assertEquals(
- Map("connector" -> "COLLECTION", "is-bounded" -> "false", "k1" -> "a", "k2" -> "b").asJava,
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
.getTable(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.T1"))
.getOptions
- )
+ ).containsAllEntriesOf(
+ util.Map.of("connector", "COLLECTION", "is-bounded", "false", "k1", "a", "k2", "b"))
val tableResult3 = tableEnv.executeSql("DROP TABLE T1")
- assertEquals(ResultKind.SUCCESS, tableResult3.getResultKind)
- assertFalse(
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
- .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.T1")))
+ .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.T1"))).isFalse
}
@Test
@@ -1093,22 +1085,22 @@ class TableEnvironmentTest {
""".stripMargin
// test create table twice
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val tableResult2 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assertTrue(
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
- .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.tbl1")))
+ .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.tbl1"))).isTrue
val tableResult3 = tableEnv.executeSql("DROP TABLE IF EXISTS tbl1")
- assertEquals(ResultKind.SUCCESS, tableResult3.getResultKind)
- assertFalse(
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
- .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.tbl1")))
+ .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.tbl1"))).isFalse
}
@Test
@@ -1126,14 +1118,14 @@ class TableEnvironmentTest {
""".stripMargin
// test crate table twice
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val tableResult2 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assertTrue(tableEnv.listTables().contains("tbl1"))
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).containsExactly("tbl1")
val tableResult3 = tableEnv.executeSql("DROP TEMPORARY TABLE IF EXISTS tbl1")
- assertEquals(ResultKind.SUCCESS, tableResult3.getResultKind)
- assertFalse(tableEnv.listTables().contains("tbl1"))
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).doesNotContain("tbl1")
}
@Test
@@ -1150,12 +1142,12 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
- assert(tableEnv.listTables().sameElements(Array[String]("tbl1")))
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).containsExactly("tbl1")
val tableResult2 = tableEnv.executeSql("DROP TEMPORARY TABLE tbl1")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assert(tableEnv.listTables().sameElements(Array.empty[String]))
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).isEmpty()
}
@Test
@@ -1172,16 +1164,16 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
- assert(tableEnv.listTables().sameElements(Array[String]("tbl1")))
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).containsExactly("tbl1")
val tableResult2 = tableEnv.executeSql("DROP TEMPORARY TABLE IF EXISTS tbl1")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assert(tableEnv.listTables().sameElements(Array.empty[String]))
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).isEmpty()
val tableResult3 = tableEnv.executeSql("DROP TEMPORARY TABLE IF EXISTS tbl1")
- assertEquals(ResultKind.SUCCESS, tableResult3.getResultKind)
- assert(tableEnv.listTables().sameElements(Array.empty[String]))
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).isEmpty()
}
@Test
@@ -1198,16 +1190,16 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
- assert(tableEnv.listTables().sameElements(Array[String]("tbl1")))
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).containsExactly("tbl1")
val tableResult2 = tableEnv.executeSql("DROP TEMPORARY TABLE tbl1")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assert(tableEnv.listTables().sameElements(Array.empty[String]))
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).isEmpty()
// fail the case
- assertThatThrownBy(() => tableEnv.executeSql("DROP TEMPORARY TABLE tbl1"))
- .isInstanceOf[ValidationException]
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("DROP TEMPORARY TABLE tbl1"))
}
@Test
@@ -1224,13 +1216,13 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
- assert(tableEnv.listTables().sameElements(Array[String]("tbl1")))
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).containsExactly("tbl1")
val tableResult2 =
tableEnv.executeSql("DROP TEMPORARY TABLE default_catalog.default_database.tbl1")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assert(tableEnv.listTables().sameElements(Array.empty[String]))
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).isEmpty()
}
@Test
@@ -1247,30 +1239,30 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
- assert(tableEnv.listTables().sameElements(Array[String]("tbl1")))
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).containsExactly("tbl1")
// fail the case
- assertThatThrownBy(
- () => tableEnv.executeSql("DROP TEMPORARY TABLE invalid_catalog.invalid_database.tbl1"))
- .isInstanceOf[ValidationException]
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(
+ () => tableEnv.executeSql("DROP TEMPORARY TABLE invalid_catalog.invalid_database.tbl1"))
}
@Test
def testExecuteSqlWithCreateAlterDropDatabase(): Unit = {
val tableResult1 = tableEnv.executeSql("CREATE DATABASE db1 COMMENT 'db1_comment'")
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
- assertTrue(tableEnv.getCatalog(tableEnv.getCurrentCatalog).get().databaseExists("db1"))
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.getCatalog(tableEnv.getCurrentCatalog).get().databaseExists("db1")).isTrue
val tableResult2 = tableEnv.executeSql("ALTER DATABASE db1 SET ('k1' = 'a', 'k2' = 'b')")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assertEquals(
- Map("k1" -> "a", "k2" -> "b").asJava,
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv.getCatalog(tableEnv.getCurrentCatalog).get().getDatabase("db1").getProperties)
+ .containsAllEntriesOf(util.Map.of("k1", "a", "k2", "b"))
val tableResult3 = tableEnv.executeSql("DROP DATABASE db1")
- assertEquals(ResultKind.SUCCESS, tableResult3.getResultKind)
- assertFalse(tableEnv.getCatalog(tableEnv.getCurrentCatalog).get().databaseExists("db1"))
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.getCatalog(tableEnv.getCurrentCatalog).get().databaseExists("db1")).isFalse
}
@Test
@@ -1279,81 +1271,81 @@ class TableEnvironmentTest {
val funcName2 = classOf[SimpleScalarFunction].getName
val tableResult1 = tableEnv.executeSql(s"CREATE FUNCTION default_database.f1 AS '$funcName'")
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
- assertTrue(
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
- .functionExists(ObjectPath.fromString("default_database.f1")))
+ .functionExists(ObjectPath.fromString("default_database.f1"))).isTrue
val tableResult2 = tableEnv.executeSql(s"ALTER FUNCTION default_database.f1 AS '$funcName2'")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assertTrue(
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
- .functionExists(ObjectPath.fromString("default_database.f1")))
+ .functionExists(ObjectPath.fromString("default_database.f1"))).isTrue
val tableResult3 = tableEnv.executeSql("DROP FUNCTION default_database.f1")
- assertEquals(ResultKind.SUCCESS, tableResult3.getResultKind)
- assertFalse(
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
- .functionExists(ObjectPath.fromString("default_database.f1")))
+ .functionExists(ObjectPath.fromString("default_database.f1"))).isFalse
val tableResult4 = tableEnv.executeSql(s"CREATE TEMPORARY SYSTEM FUNCTION f2 AS '$funcName'")
- assertEquals(ResultKind.SUCCESS, tableResult4.getResultKind)
- assertTrue(tableEnv.listUserDefinedFunctions().contains("f2"))
+ assertThatObject(tableResult4.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listUserDefinedFunctions()).containsExactly("f2")
val tableResult5 = tableEnv.executeSql("DROP TEMPORARY SYSTEM FUNCTION f2")
- assertEquals(ResultKind.SUCCESS, tableResult5.getResultKind)
- assertFalse(tableEnv.listUserDefinedFunctions().contains("f2"))
+ assertThatObject(tableResult5.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listUserDefinedFunctions()).doesNotContain("f2")
}
@Test
def testExecuteSqlWithCreateUseDropCatalog(): Unit = {
val tableResult1 =
tableEnv.executeSql("CREATE CATALOG my_catalog WITH('type'='generic_in_memory')")
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
- assertTrue(tableEnv.getCatalog("my_catalog").isPresent)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.getCatalog("my_catalog")).isPresent
- assertEquals("default_catalog", tableEnv.getCurrentCatalog)
+ assertThat(tableEnv.getCurrentCatalog).hasToString("default_catalog")
val tableResult2 = tableEnv.executeSql("USE CATALOG my_catalog")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assertEquals("my_catalog", tableEnv.getCurrentCatalog)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.getCurrentCatalog).hasToString("my_catalog")
- assertThatThrownBy(() => tableEnv.executeSql("DROP CATALOG my_catalog"))
- .isInstanceOf(classOf[ValidationException])
- .hasRootCauseMessage("Cannot drop a catalog which is currently in use.")
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("DROP CATALOG my_catalog"))
+ .havingRootCause()
+ .withMessageContaining("Cannot drop a catalog which is currently in use.")
tableEnv.executeSql("USE CATALOG default_catalog")
val tableResult3 = tableEnv.executeSql("DROP CATALOG my_catalog")
- assertEquals(ResultKind.SUCCESS, tableResult3.getResultKind)
- assertFalse(tableEnv.getCatalog("my_catalog").isPresent)
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.getCatalog("my_catalog")).isNotPresent
}
@Test
def testExecuteSqlWithUseDatabase(): Unit = {
val tableResult1 = tableEnv.executeSql("CREATE DATABASE db1 COMMENT 'db1_comment'")
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
- assertTrue(tableEnv.getCatalog(tableEnv.getCurrentCatalog).get().databaseExists("db1"))
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.getCatalog(tableEnv.getCurrentCatalog).get().databaseExists("db1")).isTrue
- assertEquals("default_database", tableEnv.getCurrentDatabase)
+ assertThat(tableEnv.getCurrentDatabase).hasToString("default_database")
val tableResult2 = tableEnv.executeSql("USE db1")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
- assertEquals("db1", tableEnv.getCurrentDatabase)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.getCurrentDatabase).hasToString("db1")
}
@Test
def testExecuteSqlWithShowCatalogs(): Unit = {
tableEnv.registerCatalog("my_catalog", new GenericInMemoryCatalog("my_catalog"))
val tableResult = tableEnv.executeSql("SHOW CATALOGS")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("catalog name", DataTypes.STRING())),
- tableResult.getResolvedSchema)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("catalog name", DataTypes.STRING())))
+ .isEqualTo(tableResult.getResolvedSchema)
checkData(
util.Arrays.asList(Row.of("default_catalog"), Row.of("my_catalog")).iterator(),
tableResult.collect())
@@ -1362,12 +1354,11 @@ class TableEnvironmentTest {
@Test
def testExecuteSqlWithShowDatabases(): Unit = {
val tableResult1 = tableEnv.executeSql("CREATE DATABASE db1 COMMENT 'db1_comment'")
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val tableResult2 = tableEnv.executeSql("SHOW DATABASES")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult2.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("database name", DataTypes.STRING())),
- tableResult2.getResolvedSchema)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("database name", DataTypes.STRING())))
+ .isEqualTo(tableResult2.getResolvedSchema)
checkData(
util.Arrays.asList(Row.of("db1"), Row.of("default_database")).iterator(),
tableResult2.collect())
@@ -1378,10 +1369,9 @@ class TableEnvironmentTest {
createTableForTests()
val tableResult2 = tableEnv.executeSql("SHOW TABLES")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult2.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("table name", DataTypes.STRING())),
- tableResult2.getResolvedSchema)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("table name", DataTypes.STRING())))
+ .isEqualTo(tableResult2.getResolvedSchema)
checkData(util.Arrays.asList(Row.of("T1")).iterator(), tableResult2.collect())
}
@@ -1389,10 +1379,10 @@ class TableEnvironmentTest {
def testExecuteSqlWithEnhancedShowTables(): Unit = {
val createCatalogResult =
tableEnv.executeSql("CREATE CATALOG catalog1 WITH('type'='generic_in_memory')")
- assertEquals(ResultKind.SUCCESS, createCatalogResult.getResultKind)
+ assertThatObject(createCatalogResult.getResultKind).isSameAs(ResultKind.SUCCESS)
val createDbResult = tableEnv.executeSql("CREATE database catalog1.db1")
- assertEquals(ResultKind.SUCCESS, createDbResult.getResultKind)
+ assertThatObject(createDbResult.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt =
"""
@@ -1406,7 +1396,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt2 =
"""
@@ -1418,13 +1408,12 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult2 = tableEnv.executeSql(createTableStmt2)
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
val tableResult3 = tableEnv.executeSql("SHOW TABLES FROM catalog1.db1 like 'p_r%'")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult3.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("table name", DataTypes.STRING())),
- tableResult3.getResolvedSchema)
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("table name", DataTypes.STRING())))
+ .isEqualTo(tableResult3.getResolvedSchema)
checkData(util.Arrays.asList(Row.of("person")).iterator(), tableResult3.collect())
}
@@ -1432,59 +1421,56 @@ class TableEnvironmentTest {
def testExecuteSqlWithEnhancedShowViews(): Unit = {
val createCatalogResult =
tableEnv.executeSql("CREATE CATALOG catalog1 WITH('type'='generic_in_memory')")
- assertEquals(ResultKind.SUCCESS, createCatalogResult.getResultKind)
+ assertThatObject(createCatalogResult.getResultKind).isSameAs(ResultKind.SUCCESS)
val createDbResult = tableEnv.executeSql("CREATE database catalog1.db1")
- assertEquals(ResultKind.SUCCESS, createDbResult.getResultKind)
+ assertThatObject(createDbResult.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt =
"""
|CREATE VIEW catalog1.db1.view1 AS SELECT 1, 'abc'
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt2 =
"""
|CREATE VIEW catalog1.db1.view2 AS SELECT 123
""".stripMargin
val tableResult2 = tableEnv.executeSql(createTableStmt2)
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
val tableResult3 = tableEnv.executeSql("SHOW VIEWS FROM catalog1.db1 like '%w1'")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult3.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("view name", DataTypes.STRING())),
- tableResult3.getResolvedSchema)
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("view name", DataTypes.STRING())))
+ .isEqualTo(tableResult3.getResolvedSchema)
checkData(util.Arrays.asList(Row.of("view1")).iterator(), tableResult3.collect())
}
@Test
def testExecuteSqlWithShowFunctions(): Unit = {
val tableResult = tableEnv.executeSql("SHOW FUNCTIONS")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("function name", DataTypes.STRING())),
- tableResult.getResolvedSchema)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("function name", DataTypes.STRING())))
+ .isEqualTo(tableResult.getResolvedSchema)
checkData(
tableEnv.listFunctions().map(Row.of(_)).toList.asJava.iterator(),
tableResult.collect())
val funcName = classOf[TestUDF].getName
val tableResult1 = tableEnv.executeSql(s"CREATE FUNCTION default_database.f1 AS '$funcName'")
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val tableResult2 = tableEnv.executeSql("SHOW USER FUNCTIONS")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult2.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("function name", DataTypes.STRING())),
- tableResult2.getResolvedSchema)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("function name", DataTypes.STRING())))
+ .isEqualTo(tableResult2.getResolvedSchema)
checkData(util.Arrays.asList(Row.of("f1")).iterator(), tableResult2.collect())
}
@Test
def testExecuteSqlWithLoadModule(): Unit = {
val result = tableEnv.executeSql("LOAD MODULE dummy")
- assertEquals(ResultKind.SUCCESS, result.getResultKind)
+ assertThatObject(result.getResultKind).isSameAs(ResultKind.SUCCESS)
checkListModules("core", "dummy")
checkListFullModules(("core", true), ("dummy", true))
@@ -1495,10 +1481,10 @@ class TableEnvironmentTest {
|)
""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(statement))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(statement))
+ .withMessageContaining(
"Option 'type' = 'dummy' is not supported since module name is used to find module")
- .isInstanceOf[ValidationException]
}
@Test
@@ -1510,7 +1496,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val result = tableEnv.executeSql(statement1)
- assertEquals(ResultKind.SUCCESS, result.getResultKind)
+ assertThatObject(result.getResultKind).isSameAs(ResultKind.SUCCESS)
checkListModules("core", "dummy")
checkListFullModules(("core", true), ("dummy", true))
@@ -1520,10 +1506,10 @@ class TableEnvironmentTest {
| 'dummy-version' = '2'
|)
""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(statement2))
- .hasMessageContaining("Could not execute LOAD MODULE `dummy` WITH ('dummy-version' = '2')." +
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(statement2))
+ .withMessageContaining("Could not execute LOAD MODULE `dummy` WITH ('dummy-version' = '2')." +
" A module with name 'dummy' already exists")
- .isInstanceOf[ValidationException]
}
@Test
@@ -1535,10 +1521,10 @@ class TableEnvironmentTest {
|)
""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(statement1))
- .hasMessageContaining(
- "Could not execute LOAD MODULE `Dummy` WITH ('dummy-version' = '1')."
- + " Unable to create module 'Dummy'.")
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(statement1))
+ .withMessageContaining("Could not execute LOAD MODULE `Dummy` WITH ('dummy-version' = '1')."
+ + " Unable to create module 'Dummy'.")
val statement2 =
"""
@@ -1547,7 +1533,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val result = tableEnv.executeSql(statement2)
- assertEquals(ResultKind.SUCCESS, result.getResultKind)
+ assertThatObject(result.getResultKind).isSameAs(ResultKind.SUCCESS)
checkListModules("core", "dummy")
checkListFullModules(("core", true), ("dummy", true))
}
@@ -1559,14 +1545,14 @@ class TableEnvironmentTest {
checkListFullModules(("core", true), ("dummy", true))
val result = tableEnv.executeSql("UNLOAD MODULE dummy")
- assertEquals(ResultKind.SUCCESS, result.getResultKind)
+ assertThatObject(result.getResultKind).isSameAs(ResultKind.SUCCESS)
checkListModules("core")
checkListFullModules(("core", true))
- assertThatThrownBy(() => tableEnv.executeSql("UNLOAD MODULE dummy"))
- .hasMessageContaining("Could not execute UNLOAD MODULE dummy." +
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("UNLOAD MODULE dummy"))
+ .withMessageContaining("Could not execute UNLOAD MODULE dummy." +
" No module with name 'dummy' exists")
- .isInstanceOf[ValidationException]
}
@Test
@@ -1576,40 +1562,40 @@ class TableEnvironmentTest {
checkListFullModules(("core", true), ("dummy", true))
val result1 = tableEnv.executeSql("USE MODULES dummy")
- assertEquals(ResultKind.SUCCESS, result1.getResultKind)
+ assertThatObject(result1.getResultKind).isSameAs(ResultKind.SUCCESS)
checkListModules("dummy")
checkListFullModules(("dummy", true), ("core", false))
val result2 = tableEnv.executeSql("USE MODULES dummy, core")
- assertEquals(ResultKind.SUCCESS, result2.getResultKind)
+ assertThatObject(result2.getResultKind).isSameAs(ResultKind.SUCCESS)
checkListModules("dummy", "core")
checkListFullModules(("dummy", true), ("core", true))
val result3 = tableEnv.executeSql("USE MODULES core, dummy")
- assertEquals(ResultKind.SUCCESS, result3.getResultKind)
+ assertThatObject(result3.getResultKind).isSameAs(ResultKind.SUCCESS)
checkListModules("core", "dummy")
checkListFullModules(("core", true), ("dummy", true))
val result4 = tableEnv.executeSql("USE MODULES core")
- assertEquals(ResultKind.SUCCESS, result4.getResultKind)
+ assertThatObject(result4.getResultKind).isSameAs(ResultKind.SUCCESS)
checkListModules("core")
checkListFullModules(("core", true), ("dummy", false))
}
@Test
def testExecuteSqlWithUseUnloadedModules(): Unit = {
- assertThatThrownBy(() => tableEnv.executeSql("USE MODULES core, dummy"))
- .hasMessageContaining("Could not execute USE MODULES: [core, dummy]. " +
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("USE MODULES core, dummy"))
+ .withMessageContaining("Could not execute USE MODULES: [core, dummy]. " +
"No module with name 'dummy' exists")
- .isInstanceOf[ValidationException]
}
@Test
def testExecuteSqlWithUseDuplicateModuleNames(): Unit = {
- assertThatThrownBy(() => tableEnv.executeSql("USE MODULES core, core"))
- .hasMessageContaining("Could not execute USE MODULES: [core, core]. " +
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("USE MODULES core, core"))
+ .withMessageContaining("Could not execute USE MODULES: [core, core]. " +
"Module 'core' appears more than once")
- .isInstanceOf[ValidationException]
}
@Test
@@ -1635,20 +1621,20 @@ class TableEnvironmentTest {
createTableForTests()
val viewResult1 = tableEnv.executeSql("CREATE VIEW IF NOT EXISTS v1 AS SELECT * FROM T1")
- assertEquals(ResultKind.SUCCESS, viewResult1.getResultKind)
- assertTrue(
+ assertThatObject(viewResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
- .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.v1")))
+ .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.v1"))).isTrue
val viewResult2 = tableEnv.executeSql("DROP VIEW IF EXISTS v1")
- assertEquals(ResultKind.SUCCESS, viewResult2.getResultKind)
- assertFalse(
+ assertThatObject(viewResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
- .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.v1")))
+ .tableExists(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.v1"))).isFalse
}
@Test
@@ -1657,12 +1643,12 @@ class TableEnvironmentTest {
val viewResult1 =
tableEnv.executeSql("CREATE TEMPORARY VIEW IF NOT EXISTS v1 AS SELECT * FROM T1")
- assertEquals(ResultKind.SUCCESS, viewResult1.getResultKind)
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "v1")))
+ assertThatObject(viewResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).containsExactly("T1", "v1")
val viewResult2 = tableEnv.executeSql("DROP TEMPORARY VIEW IF EXISTS v1")
- assertEquals(ResultKind.SUCCESS, viewResult2.getResultKind)
- assert(tableEnv.listTables().sameElements(Array[String]("T1")))
+ assertThatObject(viewResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
+ assertThat(tableEnv.listTables()).containsExactly("T1")
}
@Test
@@ -1694,17 +1680,17 @@ class TableEnvironmentTest {
|CREATE VIEW IF NOT EXISTS T3(d) AS SELECT * FROM T1
""".stripMargin
- assertThatThrownBy(
- () => {
- tableEnv.executeSql(sourceDDL)
- tableEnv.executeSql(sinkDDL)
- tableEnv.executeSql(viewDDL)
- })
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(
+ () => {
+ tableEnv.executeSql(sourceDDL)
+ tableEnv.executeSql(sinkDDL)
+ tableEnv.executeSql(viewDDL)
+ })
+ .withMessageContaining(
"VIEW definition and input fields not match:\n" +
"\tDef fields: [d].\n" +
"\tInput fields: [a, b, c].")
- .isInstanceOf[ValidationException]
}
@Test
@@ -1745,10 +1731,10 @@ class TableEnvironmentTest {
tableEnv.executeSql(sinkDDL)
tableEnv.executeSql(viewWith3ColumnDDL)
- assertThatThrownBy(() => tableEnv.executeSql(viewWith2ColumnDDL))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(viewWith2ColumnDDL))
+ .withMessageContaining(
"Could not execute CreateTable in path `default_catalog`.`default_database`.`T3`")
- .isInstanceOf[ValidationException]
}
@ParameterizedTest
@@ -1756,13 +1742,13 @@ class TableEnvironmentTest {
def testDropViewWithFullPath(isSql: Boolean): Unit = {
createViewsForDropTests()
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T2", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T2", "T3")
dropView("default_catalog.default_database.T2", isSql)
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T3")
dropView("default_catalog.default_database.T3", isSql)
- assert(tableEnv.listTables().sameElements(Array[String]("T1")))
+ assertThat(tableEnv.listTables()).containsExactly("T1")
}
@ParameterizedTest
@@ -1770,96 +1756,96 @@ class TableEnvironmentTest {
def testDropViewWithPartialPath(isSql: Boolean): Unit = {
createViewsForDropTests()
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T2", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T2", "T3")
dropView("T2", isSql)
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T3")
dropView("T3", isSql)
- assert(tableEnv.listTables().sameElements(Array[String]("T1")))
+ assertThat(tableEnv.listTables()).containsExactly("T1")
}
@Test
def testDropViewIfExistsTwice(): Unit = {
createViewsForDropTests()
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T2", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T2", "T3")
tableEnv.executeSql("DROP VIEW IF EXISTS default_catalog.default_database.T2")
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T3")
tableEnv.executeSql("DROP VIEW IF EXISTS default_catalog.default_database.T2")
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T3")
}
@Test
def testDropViewTwice(): Unit = {
createViewsForDropTests()
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T2", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T2", "T3")
tableEnv.executeSql("DROP VIEW default_catalog.default_database.T2")
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T3")
- assertThatThrownBy(() => tableEnv.executeSql("DROP VIEW default_catalog.default_database.T2"))
- .isInstanceOf(classOf[ValidationException])
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("DROP VIEW default_catalog.default_database.T2"))
}
@Test
def testDropView(): Unit = {
createViewsForDropTests()
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T2", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T2", "T3")
- assertTrue(tableEnv.dropView("default_catalog.default_database.T2"))
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T3")))
+ assertThat(tableEnv.dropView("default_catalog.default_database.T2")).isTrue
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T3")
- assertFalse(tableEnv.dropView("default_catalog.default_database.T2"))
- assertFalse(tableEnv.dropView("invalid.default_database.T2"))
- assertFalse(tableEnv.dropView("default_catalog.invalid.T2"))
- assertFalse(tableEnv.dropView("default_catalog.default_database.invalid"))
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T3")))
+ assertThat(tableEnv.dropView("default_catalog.default_database.T2")).isFalse
+ assertThat(tableEnv.dropView("invalid.default_database.T2")).isFalse
+ assertThat(tableEnv.dropView("default_catalog.invalid.T2")).isFalse
+ assertThat(tableEnv.dropView("default_catalog.default_database.invalid")).isFalse
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T3")
tableEnv.createTemporaryView("T3", tableEnv.sqlQuery("SELECT 123"))
- assertThatThrownBy(() => tableEnv.dropView("T3"))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.dropView("T3"))
+ .withMessageContaining(
"Temporary view with identifier '`default_catalog`.`default_database`.`T3`' exists. " +
"Drop it first before removing the permanent view.")
- .isInstanceOf[ValidationException]
tableEnv.dropTemporaryView("T3")
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T3")
// Now can drop permanent view
tableEnv.dropView("T3")
- assert(tableEnv.listTables().sameElements(Array[String]("T1")))
+ assertThat(tableEnv.listTables()).containsExactly("T1")
}
@Test
def testDropTable(): Unit = {
createTableForTests()
- assert(tableEnv.listTables().sameElements(Array[String]("T1")))
+ assertThat(tableEnv.listTables()).containsExactly("T1")
- assertFalse(tableEnv.dropTable("default_catalog.default_database.T2"))
- assert(tableEnv.listTables().sameElements(Array[String]("T1")))
+ assertThat(tableEnv.dropTable("default_catalog.default_database.T2")).isFalse
+ assertThat(tableEnv.listTables()).containsExactly("T1")
- assertThatThrownBy(() => tableEnv.dropTable("default_catalog.default_database.T2", false))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.dropTable("default_catalog.default_database.T2", false))
+ .withMessageContaining(
"Table with identifier 'default_catalog.default_database.T2' does not exist.")
- .isInstanceOf[ValidationException]
- assertFalse(tableEnv.dropTable("default_catalog.default_database.T2"))
- assertFalse(tableEnv.dropTable("invalid.default_database.T2"))
- assertFalse(tableEnv.dropTable("default_catalog.invalid.T2"))
- assertFalse(tableEnv.dropTable("default_catalog.default_database.invalid"))
- assert(tableEnv.listTables().sameElements(Array[String]("T1")))
+ assertThat(tableEnv.dropTable("default_catalog.default_database.T2")).isFalse
+ assertThat(tableEnv.dropTable("invalid.default_database.T2")).isFalse
+ assertThat(tableEnv.dropTable("default_catalog.invalid.T2")).isFalse
+ assertThat(tableEnv.dropTable("default_catalog.default_database.invalid")).isFalse
+ assertThat(tableEnv.listTables()).containsExactly("T1")
- assertTrue(tableEnv.dropTable("default_catalog.default_database.T1"))
- assert(tableEnv.listTables().sameElements(Array[String]()))
+ assertThat(tableEnv.dropTable("default_catalog.default_database.T1")).isTrue
+ assertThat(tableEnv.listTables()).isEmpty()
createTableForTests()
- assert(tableEnv.listTables().sameElements(Array[String]("T1")))
+ assertThat(tableEnv.listTables()).containsExactly("T1")
tableEnv.createTemporaryTable(
"T1",
@@ -1867,35 +1853,35 @@ class TableEnvironmentTest {
.forConnector("values")
.schema(Schema.newBuilder().column("col1", DataTypes.INT()).build())
.build())
- assertThatThrownBy(() => tableEnv.dropTable("T1"))
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.dropTable("T1"))
+ .withMessageContaining(
"Temporary table with identifier '`default_catalog`.`default_database`.`T1`' exists. " +
"Drop it first before removing the permanent table.")
- .isInstanceOf[ValidationException]
tableEnv.dropTemporaryTable("T1")
- assert(tableEnv.listTables().sameElements(Array[String]("T1")))
+ assertThat(tableEnv.listTables()).containsExactly("T1")
// Now can drop permanent table
tableEnv.dropTable("T1")
- assert(tableEnv.listTables().sameElements(Array[String]()))
+ assertThat(tableEnv.listTables()).isEmpty()
}
@Test
def testDropViewWithInvalidPath(): Unit = {
createViewsForDropTests()
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T2", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T2", "T3")
// failed since 'default_catalog1.default_database1.T2' is invalid path
- assertThatThrownBy(() => tableEnv.executeSql("DROP VIEW default_catalog1.default_database1.T2"))
- .isInstanceOf[ValidationException]
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("DROP VIEW default_catalog1.default_database1.T2"))
}
@Test
def testDropViewWithInvalidPathIfExists(): Unit = {
createViewsForDropTests()
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T2", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T2", "T3")
tableEnv.executeSql("DROP VIEW IF EXISTS default_catalog1.default_database1.T2")
- assert(tableEnv.listTables().sameElements(Array[String]("T1", "T2", "T3")))
+ assertThat(tableEnv.listTables()).containsExactly("T1", "T2", "T3")
}
@Test
@@ -1919,13 +1905,13 @@ class TableEnvironmentTest {
tableEnv.executeSql(sourceDDL)
tableEnv.executeSql(viewDDL)
- assert(tableEnv.listTemporaryViews().sameElements(Array[String]("T2")))
+ assertThat(tableEnv.listTemporaryViews()).containsExactly("T2")
tableEnv.executeSql("DROP TEMPORARY VIEW IF EXISTS default_catalog.default_database.T2")
- assert(tableEnv.listTemporaryViews().sameElements(Array[String]()))
+ assertThat(tableEnv.listTemporaryViews()).isEmpty()
tableEnv.executeSql("DROP TEMPORARY VIEW IF EXISTS default_catalog.default_database.T2")
- assert(tableEnv.listTemporaryViews().sameElements(Array[String]()))
+ assertThat(tableEnv.listTemporaryViews()).isEmpty()
}
@Test
@@ -1951,15 +1937,15 @@ class TableEnvironmentTest {
tableEnv.executeSql(sourceDDL)
tableEnv.executeSql(viewDDL)
- assert(tableEnv.listTemporaryViews().sameElements(Array[String]("T2")))
+ assertThat(tableEnv.listTemporaryViews()).containsExactly("T2")
tableEnv.executeSql("DROP TEMPORARY VIEW default_catalog.default_database.T2")
- assert(tableEnv.listTemporaryViews().sameElements(Array[String]()))
+ assertThat(tableEnv.listTemporaryViews()).isEmpty()
// throws ValidationException since default_catalog.default_database.T2 is not exists
- assertThatThrownBy(
- () => tableEnv.executeSql("DROP TEMPORARY VIEW default_catalog.default_database.T2"))
- .isInstanceOf[ValidationException]
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(
+ () => tableEnv.executeSql("DROP TEMPORARY VIEW default_catalog.default_database.T2"))
}
@Test
@@ -1967,21 +1953,20 @@ class TableEnvironmentTest {
createTableForTests()
val tableResult2 = tableEnv.executeSql("CREATE VIEW view1 AS SELECT * FROM T1")
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
val tableResult3 = tableEnv.executeSql("SHOW VIEWS")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult3.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("view name", DataTypes.STRING())),
- tableResult3.getResolvedSchema)
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("view name", DataTypes.STRING())))
+ .isEqualTo(tableResult3.getResolvedSchema)
checkData(util.Arrays.asList(Row.of("view1")).iterator(), tableResult3.collect())
val tableResult4 = tableEnv.executeSql("CREATE TEMPORARY VIEW view2 AS SELECT * FROM T1")
- assertEquals(ResultKind.SUCCESS, tableResult4.getResultKind)
+ assertThatObject(tableResult4.getResultKind).isSameAs(ResultKind.SUCCESS)
// SHOW VIEWS also shows temporary views
val tableResult5 = tableEnv.executeSql("SHOW VIEWS")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult5.getResultKind)
+ assertThatObject(tableResult5.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(
util.Arrays.asList(Row.of("view1"), Row.of("view2")).iterator(),
tableResult5.collect())
@@ -2001,7 +1986,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
checkExplain(
"explain plan for select * from MyTable where a > 10",
@@ -2022,7 +2007,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt1)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt2 =
"""
@@ -2035,7 +2020,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult2 = tableEnv.executeSql(createTableStmt2)
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
checkExplain(
"explain plan for insert into MySink select a, b from MyTable where a > 10",
@@ -2060,7 +2045,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = batchTableEnv.executeSql(createTableStmt1)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt2 =
"""
@@ -2076,7 +2061,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult2 = batchTableEnv.executeSql(createTableStmt2)
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
checkExplain(
"EXPLAIN PLAN FOR INSERT INTO MySink PARTITION (f2 = '123') SELECT f0, f1 FROM MyTable",
@@ -2105,7 +2090,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
// TODO we can support them later
testUnsupportedExplain("explain plan excluding attributes for select * from MyTable")
@@ -2117,7 +2102,8 @@ class TableEnvironmentTest {
}
private def testUnsupportedExplain(explain: String): Unit = {
- assertThatThrownBy(() => tableEnv.executeSql(explain))
+ assertThatExceptionOfType(classOf[SqlParserException])
+ .isThrownBy(() => tableEnv.executeSql(explain))
.satisfiesAnyOf(
anyCauseMatches(classOf[TableException], "Only default behavior is supported now"),
anyCauseMatches(classOf[SqlParserException])
@@ -2138,12 +2124,12 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val actual =
tableEnv.explainSql("select * from MyTable where a > 10", ExplainDetail.CHANGELOG_MODE)
val expected = TableTestUtil.readFromResource("/explain/testExplainSqlWithSelect.out")
- assertEquals(replaceStageId(expected), replaceStageId(actual))
+ assertThat(replaceStageId(actual)).isEqualTo(replaceStageId(expected))
}
@Test
@@ -2160,13 +2146,13 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val actual = tableEnv.explainSql(
"execute select * from MyTable where a > 10",
ExplainDetail.CHANGELOG_MODE)
val expected = TableTestUtil.readFromResource("/explain/testExplainSqlWithSelect.out")
- assertEquals(replaceStageId(expected), replaceStageId(actual))
+ assertThat(replaceStageId(actual)).isEqualTo(replaceStageId(expected))
}
@Test
@@ -2183,7 +2169,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt1)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt2 =
"""
@@ -2196,11 +2182,11 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult2 = tableEnv.executeSql(createTableStmt2)
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
val actual = tableEnv.explainSql("insert into MySink select a, b from MyTable where a > 10")
val expected = TableTestUtil.readFromResource("/explain/testExplainSqlWithInsert.out")
- assertEquals(replaceStageId(expected), replaceStageId(actual))
+ assertThat(replaceStageId(actual)).isEqualTo(replaceStageId(expected))
}
@Test
@@ -2217,7 +2203,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
checkExplain(
"explain changelog_mode, estimated_cost, json_execution_plan " +
@@ -2240,7 +2226,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt2 =
"""
@@ -2254,7 +2240,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult3 = tableEnv.executeSql(createTableStmt2)
- assertEquals(ResultKind.SUCCESS, tableResult3.getResultKind)
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS)
checkExplain(
"explain changelog_mode, estimated_cost, json_execution_plan " +
@@ -2277,7 +2263,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult1 = tableEnv.executeSql(createTableStmt1)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt2 =
"""
@@ -2290,7 +2276,7 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult2 = tableEnv.executeSql(createTableStmt2)
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
checkExplain(
"explain changelog_mode, estimated_cost, json_execution_plan " +
@@ -2405,10 +2391,10 @@ class TableEnvironmentTest {
"`ts` - INTERVAL '1' SECOND")
)
val tableResult1 = tableEnv.executeSql("describe T1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), tableResult1.collect())
val tableResult2 = tableEnv.executeSql("desc T1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), tableResult2.collect())
val expectedResult2 = util.Arrays.asList(
@@ -2417,10 +2403,10 @@ class TableEnvironmentTest {
Row.of("f", "ROW<`f0` INT NOT NULL, `f1` INT>", Boolean.box(false), null, null, null)
)
val tableResult3 = tableEnv.executeSql("describe T2")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult3.getResultKind)
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult2.iterator(), tableResult3.collect())
val tableResult4 = tableEnv.executeSql("desc T2")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult4.getResultKind)
+ assertThatObject(tableResult4.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult2.iterator(), tableResult4.collect())
// temporary view T2(x, y) masks permanent view T2(d, e, f)
@@ -2434,10 +2420,10 @@ class TableEnvironmentTest {
Row.of("x", "INT", Boolean.box(false), null, null, null),
Row.of("y", "STRING", Boolean.box(false), null, null, null));
val tableResult5 = tableEnv.executeSql("describe T2")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult5.getResultKind)
+ assertThatObject(tableResult5.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult3.iterator(), tableResult5.collect())
val tableResult6 = tableEnv.executeSql("desc T2")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult6.getResultKind)
+ assertThatObject(tableResult6.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult3.iterator(), tableResult6.collect())
}
@@ -2559,10 +2545,10 @@ class TableEnvironmentTest {
"notice: watermark")
)
val tableResult1 = tableEnv.executeSql("describe T1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), tableResult1.collect())
val tableResult2 = tableEnv.executeSql("desc T1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), tableResult2.collect())
}
@@ -2591,17 +2577,15 @@ class TableEnvironmentTest {
|""".stripMargin
tableEnv.executeSql(alterDDL)
- assertEquals(
- Map(
- "provider" -> "openai",
- "task" -> "embedding",
- "openai.endpoint" -> "openai-endpoint").asJava,
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
.getModel(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.M1"))
- .getOptions
- )
+ .getOptions)
+ .containsExactlyInAnyOrderEntriesOf(
+ util.Map.of("provider", "openai", "task", "embedding", "openai.endpoint", "openai-endpoint")
+ )
}
@Test
@@ -2619,12 +2603,12 @@ class TableEnvironmentTest {
""".stripMargin
tableEnv.executeSql(sourceDDL)
- assertThatThrownBy(
- () =>
- tableEnv
- .executeSql("ALTER MODEL M1 SET ()"))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining("ALTER MODEL SET does not support empty option.");
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(
+ () =>
+ tableEnv
+ .executeSql("ALTER MODEL M1 SET ()"))
+ .withMessageContaining("ALTER MODEL SET does not support empty option.");
}
@Test
@@ -2638,9 +2622,9 @@ class TableEnvironmentTest {
| 'task' = 'clustering'
|)
|""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(alterDDL))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining("Model `default_catalog`.`default_database`.`M1` doesn't exist.")
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(alterDDL))
+ .withMessageContaining("Model `default_catalog`.`default_database`.`M1` doesn't exist.")
}
@Test
@@ -2685,9 +2669,9 @@ class TableEnvironmentTest {
"""
|ALTER MODEL M1 RENAME TO M2
|""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(alterDDL))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining("Model `default_catalog`.`default_database`.`M1` doesn't exist.")
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(alterDDL))
+ .withMessageContaining("Model `default_catalog`.`default_database`.`M1` doesn't exist.")
}
@Test
@@ -2709,10 +2693,11 @@ class TableEnvironmentTest {
"""
|ALTER MODEL `default_catalog`.`default_database`.`M1` RENAME TO `other_catalog`.`default_database`.`M2`
|""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(alterDDL))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining(
- "The catalog name of the new model name 'other_catalog.default_database.M2' must be the same as the old model name 'default_catalog.default_database.M1'.")
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(alterDDL))
+ .withMessageContaining(
+ "The catalog name of the new model name 'other_catalog.default_database.M2' " +
+ "must be the same as the old model name 'default_catalog.default_database.M1'.")
}
@Test
@@ -2741,21 +2726,21 @@ class TableEnvironmentTest {
tableEnv.executeSql("ALTER MODEL M1 RESET ('task')");
- assertEquals(
- Map("provider" -> "openai", "openai.endpoint" -> "some-endpoint").asJava,
+ assertThat(
tableEnv
.getCatalog(tableEnv.getCurrentCatalog)
.get()
.getModel(ObjectPath.fromString(s"${tableEnv.getCurrentDatabase}.M1"))
.getOptions
- )
+ ).containsExactlyInAnyOrderEntriesOf(
+ util.Map.of("provider", "openai", "openai.endpoint", "some-endpoint"))
}
@Test
def testAlterModelResetNonExist(): Unit = {
- assertThatThrownBy(() => tableEnv.executeSql("ALTER MODEL M1 RESET ('task')"))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining("Model `default_catalog`.`default_database`.`M1` doesn't exist.")
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("ALTER MODEL M1 RESET ('task')"))
+ .withMessageContaining("Model `default_catalog`.`default_database`.`M1` doesn't exist.")
}
@Test
@@ -2778,12 +2763,12 @@ class TableEnvironmentTest {
""".stripMargin
tableEnv.executeSql(sourceDDL)
- assertThatThrownBy(
- () =>
- tableEnv
- .executeSql("ALTER MODEL M1 RESET ()"))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining("ALTER MODEL RESET does not support empty key.");
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(
+ () =>
+ tableEnv
+ .executeSql("ALTER MODEL M1 RESET ()"))
+ .withMessageContaining("ALTER MODEL RESET does not support empty key.");
}
@Test
@@ -2798,10 +2783,10 @@ class TableEnvironmentTest {
| 'openai.endpoint' = 'some-endpoint'
|)
""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(sourceDDL))
- .isInstanceOf(classOf[SqlValidateException])
- .hasMessageContaining("Input column list can not be empty with non-empty output column list.")
-
+ assertThatExceptionOfType(classOf[SqlValidateException])
+ .isThrownBy(() => tableEnv.executeSql(sourceDDL))
+ .withMessageContaining(
+ "Input column list can not be empty with non-empty output column list.")
}
@Test
@@ -2817,10 +2802,9 @@ class TableEnvironmentTest {
| 'openai.endpoint' = 'some-endpoint'
|)
""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(sourceDDL))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining("Duplicate input column name: 'f1'.")
-
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(sourceDDL))
+ .withMessageContaining("Duplicate input column name: 'f1'.")
}
@Test
@@ -2836,10 +2820,9 @@ class TableEnvironmentTest {
| 'openai.endpoint' = 'some-endpoint'
|)
""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(sourceDDL))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining("Duplicate output column name: 'f2'.")
-
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(sourceDDL))
+ .withMessageContaining("Duplicate output column name: 'f2'.")
}
@Test
@@ -2854,9 +2837,9 @@ class TableEnvironmentTest {
| 'openai.endpoint' = 'some-endpoint'
|)
""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(sourceDDL))
- .isInstanceOf(classOf[SqlValidateException])
- .hasMessageContaining("")
+ assertThatExceptionOfType(classOf[SqlValidateException])
+ .isThrownBy(() => tableEnv.executeSql(sourceDDL))
+ .withMessageContaining("")
}
@Test
@@ -2868,9 +2851,9 @@ class TableEnvironmentTest {
| OUTPUT(f2 string)
|with ()
""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(sourceDDL))
- .isInstanceOf(classOf[SqlValidateException])
- .hasMessageContaining("Model property list can not be empty.")
+ assertThatExceptionOfType(classOf[SqlValidateException])
+ .isThrownBy(() => tableEnv.executeSql(sourceDDL))
+ .withMessageContaining("Model property list can not be empty.")
}
@Test
@@ -2895,10 +2878,10 @@ class TableEnvironmentTest {
Row.of("f2", "STRING", Boolean.box(true), Boolean.box(false), null)
)
val modelResult1 = tableEnv.executeSql("describe MODEL M1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, modelResult1.getResultKind)
+ assertThatObject(modelResult1.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), modelResult1.collect())
val modelResult2 = tableEnv.executeSql("desc model M1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, modelResult2.getResultKind)
+ assertThatObject(modelResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), modelResult2.collect())
}
@@ -2924,10 +2907,10 @@ class TableEnvironmentTest {
Row.of("f2", "STRING", Boolean.box(true), Boolean.box(false))
)
val modelResult1 = tableEnv.executeSql("describe MODEL M1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, modelResult1.getResultKind)
+ assertThatObject(modelResult1.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), modelResult1.collect())
val modelResult2 = tableEnv.executeSql("desc model M1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, modelResult2.getResultKind)
+ assertThatObject(modelResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), modelResult2.collect())
}
@@ -2948,10 +2931,10 @@ class TableEnvironmentTest {
val expectedResult1 = new util.ArrayList[Row]()
val modelResult1 = tableEnv.executeSql("describe model M1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, modelResult1.getResultKind)
+ assertThatObject(modelResult1.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), modelResult1.collect())
val modelResult2 = tableEnv.executeSql("desc model M1")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, modelResult2.getResultKind)
+ assertThatObject(modelResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
checkData(expectedResult1.iterator(), modelResult2.collect())
}
@@ -2984,7 +2967,7 @@ class TableEnvironmentTest {
|)
|""".stripMargin
val row = tableEnv.executeSql("SHOW CREATE MODEL M1").collect().next()
- assertEquals(expectedDDL, row.getField(0))
+ assertThat(row.getField(0)).isEqualTo(expectedDDL)
}
@Test
@@ -3025,7 +3008,7 @@ class TableEnvironmentTest {
|)
|""".stripMargin
val row = tableEnv.executeSql("SHOW CREATE MODEL M1").collect().next()
- assertEquals(expectedDDL, row.getField(0))
+ assertThat(row.getField(0)).isEqualTo(expectedDDL)
}
@Test
@@ -3057,14 +3040,14 @@ class TableEnvironmentTest {
|)
|""".stripMargin
val row = tableEnv.executeSql("SHOW CREATE MODEL M1").collect().next()
- assertEquals(expectedDDL, row.getField(0))
+ assertThat(row.getField(0)).isEqualTo(expectedDDL)
}
@Test
def testShowCreateNonExistModel(): Unit = {
- assertThatThrownBy(() => tableEnv.executeSql("SHOW CREATE MODEL M1"))
- .isInstanceOf(classOf[ValidationException])
- .hasMessage(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql("SHOW CREATE MODEL M1"))
+ .withMessage(
"Could not execute SHOW CREATE MODEL. Model with identifier `default_catalog`.`default_database`.`M1` does not exist.")
}
@@ -3093,7 +3076,7 @@ class TableEnvironmentTest {
|)
|""".stripMargin
val row = tableEnv.executeSql("SHOW CREATE MODEL M1").collect().next()
- assertEquals(expectedDDL, row.getField(0))
+ assertThat(row.getField(0)).isEqualTo(expectedDDL)
}
@Test
@@ -3123,7 +3106,7 @@ class TableEnvironmentTest {
|)
|""".stripMargin
val row = tableEnv.executeSql("SHOW CREATE MODEL M1").collect().next()
- assertEquals(expectedDDL, row.getField(0))
+ assertThat(row.getField(0)).isEqualTo(expectedDDL)
}
@Test
@@ -3152,9 +3135,9 @@ class TableEnvironmentTest {
"""
|ALTER MODEL M1 RENAME TO M2
|""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(alterDDL))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining("Model `default_catalog`.`default_database`.`M1` doesn't exist.")
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(alterDDL))
+ .withMessageContaining("Model `default_catalog`.`default_database`.`M1` doesn't exist.")
}
@Test
@@ -3163,9 +3146,9 @@ class TableEnvironmentTest {
"""
|DROP MODEL M1
|""".stripMargin
- assertThatThrownBy(() => tableEnv.executeSql(dropDDL))
- .isInstanceOf(classOf[ValidationException])
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.executeSql(dropDDL))
+ .withMessageContaining(
"Model with identifier 'default_catalog.default_database.M1' does not exist.")
}
@@ -3193,23 +3176,22 @@ class TableEnvironmentTest {
|""".stripMargin
}
val tableResult1 = tableEnv.executeSql(createModelStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val tableResult2 = tableEnv.executeSql("SHOW MODELS")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult2.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("model name", DataTypes.STRING())),
- tableResult2.getResolvedSchema)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("model name", DataTypes.STRING())))
+ .isEqualTo(tableResult2.getResolvedSchema)
checkData(util.Arrays.asList(Row.of("M1")).iterator(), tableResult2.collect())
}
def testExecuteSqlWithEnhancedShowModels(): Unit = {
val createCatalogResult =
tableEnv.executeSql("CREATE CATALOG catalog1 WITH('type'='generic_in_memory')")
- assertEquals(ResultKind.SUCCESS, createCatalogResult.getResultKind)
+ assertThatObject(createCatalogResult.getResultKind).isSameAs(ResultKind.SUCCESS)
val createDbResult = tableEnv.executeSql("CREATE database catalog1.db1")
- assertEquals(ResultKind.SUCCESS, createDbResult.getResultKind)
+ assertThatObject(createDbResult.getResultKind).isSameAs(ResultKind.SUCCESS)
val createModelStmt =
"""
@@ -3223,7 +3205,7 @@ class TableEnvironmentTest {
|)
|""".stripMargin
val tableResult1 = tableEnv.executeSql(createModelStmt)
- assertEquals(ResultKind.SUCCESS, tableResult1.getResultKind)
+ assertThatObject(tableResult1.getResultKind).isSameAs(ResultKind.SUCCESS)
val createTableStmt2 =
"""
@@ -3238,21 +3220,20 @@ class TableEnvironmentTest {
|""".stripMargin
val tableResult2 = tableEnv.executeSql(createTableStmt2)
- assertEquals(ResultKind.SUCCESS, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS)
val tableResult3 = tableEnv.executeSql("SHOW MODELS FROM catalog1.db1 like 'you_mo%'")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult3.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("model name", DataTypes.STRING())),
- tableResult3.getResolvedSchema)
+ assertThatObject(tableResult3.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("model name", DataTypes.STRING())))
+ .isEqualTo(tableResult3.getResolvedSchema)
checkData(util.Arrays.asList(Row.of("your_model")).iterator(), tableResult3.collect())
}
@Test
def testGetNonExistModel(): Unit = {
- assertThatThrownBy(() => tableEnv.fromModel("MyModel"))
- .hasMessageContaining("Model `MyModel` was not found")
- .isInstanceOf[ValidationException]
+ assertThatExceptionOfType(classOf[ValidationException])
+ .isThrownBy(() => tableEnv.fromModel("MyModel"))
+ .withMessageContaining("Model `MyModel` was not found")
}
@Test
@@ -3277,69 +3258,68 @@ class TableEnvironmentTest {
tableEnv.registerCatalog(listener.getName, listener)
// test temporary table
tableEnv.executeSql("create temporary table tbl1 (x int)")
- assertEquals(0, listener.numTempTable)
+ assertThat(listener.numTempTable).isZero
tableEnv.executeSql(s"create temporary table ${listener.getName}.`default`.tbl1 (x int)")
- assertEquals(1, listener.numTempTable)
+ assertThat(listener.numTempTable).isOne
val tableResult = tableEnv
.asInstanceOf[TableEnvironmentInternal]
.getCatalogManager
.getTable(ObjectIdentifier.of(listener.getName, "default", "tbl1"))
- assertTrue(tableResult.isPresent)
- assertEquals(listener.tableComment, tableResult.get().getTable[CatalogBaseTable].getComment)
+ assertThat(tableResult).isPresent
+ assertThat(tableResult.get().getTable[CatalogBaseTable].getComment)
+ .isEqualTo(listener.tableComment)
tableEnv.executeSql("drop temporary table tbl1")
- assertEquals(1, listener.numTempTable)
+ assertThat(listener.numTempTable).isOne
tableEnv.executeSql(s"drop temporary table ${listener.getName}.`default`.tbl1")
- assertEquals(0, listener.numTempTable)
+ assertThat(listener.numTempTable).isZero
tableEnv.useCatalog(listener.getName)
tableEnv.executeSql("create temporary table tbl1 (x int)")
- assertEquals(1, listener.numTempTable)
+ assertThat(listener.numTempTable).isOne
tableEnv.executeSql("drop temporary table tbl1")
- assertEquals(0, listener.numTempTable)
+ assertThat(listener.numTempTable).isZero
tableEnv.useCatalog(currentCat)
// test temporary view
tableEnv.executeSql("create temporary view v1 as select 1")
- assertEquals(0, listener.numTempTable)
+ assertThat(listener.numTempTable).isZero
tableEnv.executeSql(s"create temporary view ${listener.getName}.`default`.v1 as select 1")
- assertEquals(1, listener.numTempTable)
+ assertThat(listener.numTempTable).isOne
val viewResult = tableEnv
.asInstanceOf[TableEnvironmentInternal]
.getCatalogManager
.getTable(ObjectIdentifier.of(listener.getName, "default", "v1"))
- assertTrue(viewResult.isPresent)
- assertEquals(listener.tableComment, viewResult.get().getTable[CatalogBaseTable].getComment)
+ assertThat(viewResult).isPresent
+ assertThat(viewResult.get().getTable[CatalogBaseTable].getComment)
+ .isEqualTo(listener.tableComment)
tableEnv.executeSql("drop temporary view v1")
- assertEquals(1, listener.numTempTable)
+ assertThat(listener.numTempTable).isOne
tableEnv.executeSql(s"drop temporary view ${listener.getName}.`default`.v1")
- assertEquals(0, listener.numTempTable)
+ assertThat(listener.numTempTable).isZero
tableEnv.useCatalog(listener.getName)
tableEnv.executeSql("create temporary view v1 as select 1")
- assertEquals(1, listener.numTempTable)
+ assertThat(listener.numTempTable).isOne
tableEnv.executeSql("drop temporary view v1")
- assertEquals(0, listener.numTempTable)
+ assertThat(listener.numTempTable).isZero
tableEnv.useCatalog(currentCat)
// test temporary function
val clzName = "foo.class.name"
- try {
- tableEnv.executeSql(s"create temporary function func1 as '$clzName'")
- fail("Creating a temporary function with invalid class should fail")
- } catch {
- case _: Exception => // expected
- }
- assertEquals(0, listener.numTempFunc)
+ assertThatExceptionOfType(classOf[Exception])
+ .isThrownBy(() => tableEnv.executeSql(s"create temporary function func1 as '$clzName'"))
+
+ assertThat(listener.numTempFunc).isZero
tableEnv.executeSql(
s"create temporary function ${listener.getName}.`default`.func1 as '$clzName'")
- assertEquals(1, listener.numTempFunc)
+ assertThat(listener.numTempFunc).isOne
tableEnv.executeSql("drop temporary function if exists func1")
- assertEquals(1, listener.numTempFunc)
+ assertThat(listener.numTempFunc).isOne
tableEnv.executeSql(s"drop temporary function ${listener.getName}.`default`.func1")
- assertEquals(0, listener.numTempFunc)
+ assertThat(listener.numTempFunc).isZero
tableEnv.useCatalog(listener.getName)
tableEnv.executeSql(s"create temporary function func1 as '$clzName'")
- assertEquals(1, listener.numTempFunc)
+ assertThat(listener.numTempFunc).isOne
tableEnv.executeSql("drop temporary function func1")
- assertEquals(0, listener.numTempFunc)
+ assertThat(listener.numTempFunc).isZero
tableEnv.useCatalog(currentCat)
listener.close()
@@ -3359,9 +3339,9 @@ class TableEnvironmentTest {
tableEnv.getConfig.set(ExecutionOptions.RUNTIME_MODE, RuntimeExecutionMode.BATCH)
- assertThatThrownBy(() => tableEnv.explainSql("select * from MyTable"))
- .isInstanceOf(classOf[IllegalArgumentException])
- .hasMessageContaining(
+ assertThatExceptionOfType(classOf[IllegalArgumentException])
+ .isThrownBy(() => tableEnv.explainSql("select * from MyTable"))
+ .withMessageContaining(
"Mismatch between configured runtime mode and actual runtime mode. " +
"Currently, the 'execution.runtime-mode' can only be set when instantiating the " +
"table environment. Subsequent changes are not supported. " +
@@ -3387,7 +3367,7 @@ class TableEnvironmentTest {
var tableResult = tableEnv.executeSql(
"alter table tbl add partition " +
"(b=1000,c='2020-05-01') partition (b=2000,c='2020-01-01') with ('k'='v')")
- assertEquals(ResultKind.SUCCESS, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS)
val spec1 = new CatalogPartitionSpec(Map("b" -> "1000", "c" -> "2020-05-01").asJava)
val spec2 = new CatalogPartitionSpec(Map("b" -> "2000", "c" -> "2020-01-01").asJava)
@@ -3397,24 +3377,24 @@ class TableEnvironmentTest {
val tablePath = new ObjectPath("default_database", "tbl")
val actual = catalog.listPartitions(tablePath)
// assert partition spec
- assertEquals(List(spec1, spec2).asJava, actual)
+ assertThatList(actual).containsExactly(spec1, spec2)
val part1 = catalog.getPartition(tablePath, spec1)
val part2 = catalog.getPartition(tablePath, spec2)
// assert partition properties
- assertEquals(Collections.emptyMap(), part1.getProperties)
- assertEquals(Collections.singletonMap("k", "v"), part2.getProperties)
+ assertThat(part1.getProperties).isEmpty()
+ assertThat(part2.getProperties).isEqualTo(util.Map.of("k", "v"))
// add existed partition with if not exists
tableResult =
tableEnv.executeSql("alter table tbl add if not exists partition (b=1000,c='2020-05-01')")
- assertEquals(ResultKind.SUCCESS, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS)
// add existed partition without if not exists
- assertThatThrownBy(
- () => tableEnv.executeSql("alter table tbl add partition (b=1000,c='2020-05-01')"))
- .isInstanceOf(classOf[TableException])
- .hasMessageContaining("Could not execute ALTER TABLE default_catalog.default_database.tbl" +
+ assertThatExceptionOfType(classOf[TableException])
+ .isThrownBy(
+ () => tableEnv.executeSql("alter table tbl add partition (b=1000,c='2020-05-01')"))
+ .withMessageContaining("Could not execute ALTER TABLE default_catalog.default_database.tbl" +
" ADD PARTITION (b=1000, c=2020-05-01)")
}
@@ -3521,7 +3501,7 @@ class TableEnvironmentTest {
for (viewSql <- viewDdls) {
val view = tableEnv.executeSql(viewSql)
- assertEquals(ResultKind.SUCCESS, view.getResultKind)
+ assertThatObject(view.getResultKind).isSameAs(ResultKind.SUCCESS)
}
}
@@ -3538,30 +3518,28 @@ class TableEnvironmentTest {
|)
""".stripMargin
val tableResult = tableEnv.executeSql(createTableStmt)
- assertEquals(ResultKind.SUCCESS, tableResult.getResultKind)
+ assertThatObject(tableResult.getResultKind).isSameAs(ResultKind.SUCCESS)
}
private def checkData(expected: util.Iterator[Row], actual: util.Iterator[Row]): Unit = {
while (expected.hasNext && actual.hasNext) {
- assertEquals(expected.next(), actual.next())
+ assertThat(actual.next()).isEqualTo(expected.next())
}
- assertEquals(expected.hasNext, actual.hasNext)
+ assertThat(actual.hasNext).isEqualTo(expected.hasNext)
}
private def validateShowModules(expectedEntries: (String, java.lang.Boolean)*): Unit = {
val showModules = tableEnv.executeSql("SHOW MODULES")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, showModules.getResultKind)
- assertEquals(
- ResolvedSchema.of(Column.physical("module name", DataTypes.STRING())),
- showModules.getResolvedSchema)
+ assertThatObject(showModules.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(ResolvedSchema.of(Column.physical("module name", DataTypes.STRING())))
+ .isEqualTo(showModules.getResolvedSchema)
val showFullModules = tableEnv.executeSql("SHOW FULL MODULES")
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, showFullModules.getResultKind)
- assertEquals(
+ assertThatObject(showFullModules.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
+ assertThat(showFullModules.getResolvedSchema).isEqualTo(
ResolvedSchema.physical(
Array[String]("module name", "used"),
- Array[DataType](DataTypes.STRING(), DataTypes.BOOLEAN())),
- showFullModules.getResolvedSchema
+ Array[DataType](DataTypes.STRING(), DataTypes.BOOLEAN()))
)
// show modules only list used modules
@@ -3578,16 +3556,15 @@ class TableEnvironmentTest {
private def checkListModules(expected: String*): Unit = {
val actual = tableEnv.listModules()
for ((module, i) <- expected.zipWithIndex) {
- assertEquals(module, actual.apply(i))
+ assertThat(actual.apply(i)).isEqualTo(module)
}
}
private def checkListFullModules(expected: (String, java.lang.Boolean)*): Unit = {
val actual = tableEnv.listFullModules()
for ((elem, i) <- expected.zipWithIndex) {
- assertEquals(
- new ModuleEntry(elem._1, elem._2).asInstanceOf[Object],
- actual.apply(i).asInstanceOf[Object])
+ assertThat(new ModuleEntry(elem._1, elem._2).asInstanceOf[Object])
+ .isEqualTo(actual.apply(i).asInstanceOf[Object])
}
}
@@ -3603,8 +3580,8 @@ class TableEnvironmentTest {
new Configuration(),
false)
val source = TableFactoryUtil.findAndCreateTableSource(context)
- assertTrue(source.isInstanceOf[CollectionTableSource])
- assertEquals(expectToBeBounded, source.asInstanceOf[CollectionTableSource].isBounded)
+ assertThat(source).isInstanceOf(classOf[CollectionTableSource])
+ assertThat(source.asInstanceOf[CollectionTableSource].isBounded).isEqualTo(expectToBeBounded)
}
private def checkExplain(sql: String, resultPath: String, streaming: Boolean = true): Unit = {
@@ -3613,16 +3590,16 @@ class TableEnvironmentTest {
} else {
batchTableEnv.executeSql(sql)
}
- assertEquals(ResultKind.SUCCESS_WITH_CONTENT, tableResult2.getResultKind)
+ assertThatObject(tableResult2.getResultKind).isSameAs(ResultKind.SUCCESS_WITH_CONTENT)
val it = tableResult2.collect()
- assertTrue(it.hasNext)
+ assertThat(it).hasNext
val row = it.next()
- assertEquals(1, row.getArity)
+ assertThat(row.getArity).isOne
val actual = replaceNodeIdInOperator(replaceStreamNodeId(row.getField(0).toString.trim))
val expected = replaceNodeIdInOperator(
replaceStreamNodeId(TableTestUtil.readFromResource(resultPath).trim))
- assertEquals(replaceStageId(expected), replaceStageId(actual))
- assertFalse(it.hasNext)
+ assertThat(replaceStageId(expected)).isEqualTo(replaceStageId(actual))
+ assertThat(it.hasNext).isFalse
}
class ListenerCatalog(name: String)
(flink) 01/02: [FLINK-38766][table] Add support for `ALTER MATERIALIZED TABLE ADD` support
Posted by sn...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
snuyanzin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/flink.git
commit fc85065a1c010ae2d0f2569aece5cc5a57870050
Author: Sergey Nuyanzin <sn...@gmail.com>
AuthorDate: Wed Nov 26 12:30:58 2025 +0100
[FLINK-38766][table] Add support for `ALTER MATERIALIZED TABLE ADD` support
This closes #27302.
---
.../src/test/resources/sql/table.q | 2 +-
.../MaterializedTableManager.java | 71 +-
.../service/MaterializedTableStatementITCase.java | 865 +++++++--------------
.../src/main/codegen/includes/parserImpls.ftl | 8 +-
.../ddl/SqlAlterMaterializedTableSchema.java | 8 +-
.../AlterMaterializedTableAsQueryOperation.java | 4 +-
.../AlterMaterializedTableChangeOperation.java | 13 +-
.../catalog/CatalogBaseTableResolutionTest.java | 15 +-
.../flink/table/catalog/CatalogPropertiesUtil.java | 15 +-
.../table/catalog/CatalogPropertiesUtilTest.java | 9 +-
.../AbstractAlterMaterializedTableConverter.java | 53 +-
.../AbstractCreateMaterializedTableConverter.java | 7 +-
.../operations/converters/SchemaAddConverter.java | 33 +-
.../operations/converters/SchemaConverter.java | 48 +-
.../converters/SchemaModifyConverter.java | 38 +-
...rMaterializedTableAddDistributionConverter.java | 48 +-
.../SqlAlterMaterializedTableAsQueryConverter.java | 22 +-
...MaterializedTableDropDistributionConverter.java | 15 +-
...terializedTableModifyDistributionConverter.java | 18 +-
.../SqlAlterMaterializedTableSchemaConverter.java | 70 ++
...SqlCreateOrAlterMaterializedTableConverter.java | 53 +-
.../operations/converters/SqlNodeConverters.java | 2 +
.../table/AbstractAlterTableConverter.java | 4 +-
.../converters/table/MergeTableAsUtil.java | 65 +-
.../SqlAlterTableAddDistributionConverter.java | 2 +-
.../table/SqlAlterTableSchemaAddConverter.java | 5 +-
.../table/SqlAlterTableSchemaConverter.java | 6 +-
.../table/SqlAlterTableSchemaModifyConverter.java | 5 +-
.../planner/utils/MaterializedTableUtils.java | 70 ++
.../operations/SqlDdlToOperationConverterTest.java | 25 +-
...erializedTableNodeToOperationConverterTest.java | 724 +++++++++--------
.../flink/table/api/TableEnvironmentTest.scala | 16 +-
.../catalog/TestFileSystemCatalogTest.java | 25 +-
33 files changed, 1091 insertions(+), 1273 deletions(-)
diff --git a/flink-table/flink-sql-client/src/test/resources/sql/table.q b/flink-table/flink-sql-client/src/test/resources/sql/table.q
index 8ac9fbf85ee..b5caeafb5cc 100644
--- a/flink-table/flink-sql-client/src/test/resources/sql/table.q
+++ b/flink-table/flink-sql-client/src/test/resources/sql/table.q
@@ -536,7 +536,7 @@ WITH (
alter table orders2 add product string first;
[ERROR] Could not execute SQL statement. Reason:
org.apache.flink.table.api.ValidationException: Failed to execute ALTER TABLE statement.
-Try to add a column `product` which already exists in the table.
+Column `product` already exists in the table.
!error
# test alter table schema add a column after a nonexistent column
diff --git a/flink-table/flink-sql-gateway/src/main/java/org/apache/flink/table/gateway/service/materializedtable/MaterializedTableManager.java b/flink-table/flink-sql-gateway/src/main/java/org/apache/flink/table/gateway/service/materializedtable/MaterializedTableManager.java
index 3c49ca0a59e..f33365b666f 100644
--- a/flink-table/flink-sql-gateway/src/main/java/org/apache/flink/table/gateway/service/materializedtable/MaterializedTableManager.java
+++ b/flink-table/flink-sql-gateway/src/main/java/org/apache/flink/table/gateway/service/materializedtable/MaterializedTableManager.java
@@ -32,6 +32,8 @@ import org.apache.flink.table.api.ValidationException;
import org.apache.flink.table.api.config.TableConfigOptions;
import org.apache.flink.table.api.internal.TableEnvironmentInternal;
import org.apache.flink.table.catalog.CatalogMaterializedTable;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshStatus;
import org.apache.flink.table.catalog.Column;
import org.apache.flink.table.catalog.IntervalFreshness;
import org.apache.flink.table.catalog.ObjectIdentifier;
@@ -39,7 +41,6 @@ import org.apache.flink.table.catalog.ResolvedCatalogBaseTable;
import org.apache.flink.table.catalog.ResolvedCatalogMaterializedTable;
import org.apache.flink.table.catalog.ResolvedSchema;
import org.apache.flink.table.catalog.TableChange;
-import org.apache.flink.table.catalog.TableChange.MaterializedTableChange;
import org.apache.flink.table.data.GenericMapData;
import org.apache.flink.table.data.GenericRowData;
import org.apache.flink.table.data.RowData;
@@ -198,7 +199,7 @@ public class MaterializedTableManager {
CreateMaterializedTableOperation createMaterializedTableOperation) {
ResolvedCatalogMaterializedTable materializedTable =
createMaterializedTableOperation.getCatalogMaterializedTable();
- if (CatalogMaterializedTable.RefreshMode.CONTINUOUS == materializedTable.getRefreshMode()) {
+ if (RefreshMode.CONTINUOUS == materializedTable.getRefreshMode()) {
createMaterializedTableInContinuousMode(
operationExecutor, handle, createMaterializedTableOperation);
} else {
@@ -283,7 +284,7 @@ public class MaterializedTableManager {
handle,
materializedTableIdentifier,
catalogMaterializedTable,
- CatalogMaterializedTable.RefreshStatus.ACTIVATED,
+ RefreshStatus.ACTIVATED,
refreshHandler.asSummaryString(),
serializedRefreshHandler);
} catch (Exception e) {
@@ -308,15 +309,14 @@ public class MaterializedTableManager {
getCatalogMaterializedTable(operationExecutor, tableIdentifier);
// Initialization phase doesn't support resume operation.
- if (CatalogMaterializedTable.RefreshStatus.INITIALIZING
- == materializedTable.getRefreshStatus()) {
+ if (RefreshStatus.INITIALIZING == materializedTable.getRefreshStatus()) {
throw new SqlExecutionException(
String.format(
"Materialized table %s is being initialized and does not support suspend operation.",
tableIdentifier));
}
- if (CatalogMaterializedTable.RefreshMode.CONTINUOUS == materializedTable.getRefreshMode()) {
+ if (RefreshMode.CONTINUOUS == materializedTable.getRefreshMode()) {
suspendContinuousRefreshJob(
operationExecutor, handle, tableIdentifier, materializedTable);
} else {
@@ -334,8 +334,7 @@ public class MaterializedTableManager {
ContinuousRefreshHandler refreshHandler =
deserializeContinuousHandler(materializedTable.getSerializedRefreshHandler());
- if (CatalogMaterializedTable.RefreshStatus.SUSPENDED
- == materializedTable.getRefreshStatus()) {
+ if (RefreshStatus.SUSPENDED == materializedTable.getRefreshStatus()) {
throw new SqlExecutionException(
String.format(
"Materialized table %s continuous refresh job has been suspended, jobId is %s.",
@@ -356,7 +355,7 @@ public class MaterializedTableManager {
handle,
tableIdentifier,
materializedTable,
- CatalogMaterializedTable.RefreshStatus.SUSPENDED,
+ RefreshStatus.SUSPENDED,
updateRefreshHandler.asSummaryString(),
serializeContinuousHandler(updateRefreshHandler));
} catch (Exception e) {
@@ -373,8 +372,7 @@ public class MaterializedTableManager {
OperationHandle handle,
ObjectIdentifier tableIdentifier,
CatalogMaterializedTable materializedTable) {
- if (CatalogMaterializedTable.RefreshStatus.SUSPENDED
- == materializedTable.getRefreshStatus()) {
+ if (RefreshStatus.SUSPENDED == materializedTable.getRefreshStatus()) {
throw new SqlExecutionException(
String.format(
"Materialized table %s refresh workflow has been suspended.",
@@ -401,7 +399,7 @@ public class MaterializedTableManager {
handle,
tableIdentifier,
materializedTable,
- CatalogMaterializedTable.RefreshStatus.SUSPENDED,
+ RefreshStatus.SUSPENDED,
refreshHandler.asSummaryString(),
materializedTable.getSerializedRefreshHandler());
} catch (Exception e) {
@@ -422,16 +420,14 @@ public class MaterializedTableManager {
getCatalogMaterializedTable(operationExecutor, tableIdentifier);
// Initialization phase doesn't support resume operation.
- if (CatalogMaterializedTable.RefreshStatus.INITIALIZING
- == catalogMaterializedTable.getRefreshStatus()) {
+ if (RefreshStatus.INITIALIZING == catalogMaterializedTable.getRefreshStatus()) {
throw new SqlExecutionException(
String.format(
"Materialized table %s is being initialized and does not support resume operation.",
tableIdentifier));
}
- if (CatalogMaterializedTable.RefreshMode.CONTINUOUS
- == catalogMaterializedTable.getRefreshMode()) {
+ if (RefreshMode.CONTINUOUS == catalogMaterializedTable.getRefreshMode()) {
resumeContinuousRefreshJob(
operationExecutor,
handle,
@@ -461,8 +457,7 @@ public class MaterializedTableManager {
catalogMaterializedTable.getSerializedRefreshHandler());
// Repeated resume continuous refresh job is not supported
- if (CatalogMaterializedTable.RefreshStatus.ACTIVATED
- == catalogMaterializedTable.getRefreshStatus()) {
+ if (RefreshStatus.ACTIVATED == catalogMaterializedTable.getRefreshStatus()) {
JobStatus jobStatus = getJobStatus(operationExecutor, handle, refreshHandler);
if (!jobStatus.isGloballyTerminalState()) {
throw new SqlExecutionException(
@@ -497,8 +492,7 @@ public class MaterializedTableManager {
CatalogMaterializedTable catalogMaterializedTable,
Map<String, String> dynamicOptions) {
// Repeated resume refresh workflow is not supported
- if (CatalogMaterializedTable.RefreshStatus.ACTIVATED
- == catalogMaterializedTable.getRefreshStatus()) {
+ if (RefreshStatus.ACTIVATED == catalogMaterializedTable.getRefreshStatus()) {
throw new SqlExecutionException(
String.format(
"Materialized table %s refresh workflow has been resumed.",
@@ -525,7 +519,7 @@ public class MaterializedTableManager {
handle,
tableIdentifier,
catalogMaterializedTable,
- CatalogMaterializedTable.RefreshStatus.ACTIVATED,
+ RefreshStatus.ACTIVATED,
refreshHandler.asSummaryString(),
catalogMaterializedTable.getSerializedRefreshHandler());
} catch (Exception e) {
@@ -584,7 +578,7 @@ public class MaterializedTableManager {
handle,
materializedTableIdentifier,
catalogMaterializedTable,
- CatalogMaterializedTable.RefreshStatus.ACTIVATED,
+ RefreshStatus.ACTIVATED,
continuousRefreshHandler.asSummaryString(),
serializedBytes);
}
@@ -820,7 +814,7 @@ public class MaterializedTableManager {
ResolvedCatalogMaterializedTable oldMaterializedTable =
getCatalogMaterializedTable(operationExecutor, tableIdentifier);
- if (CatalogMaterializedTable.RefreshMode.FULL == oldMaterializedTable.getRefreshMode()) {
+ if (RefreshMode.FULL == oldMaterializedTable.getRefreshMode()) {
// directly apply the alter operation
AlterMaterializedTableChangeOperation alterMaterializedTableChangeOperation =
new AlterMaterializedTableChangeOperation(
@@ -831,8 +825,7 @@ public class MaterializedTableManager {
handle, alterMaterializedTableChangeOperation);
}
- if (CatalogMaterializedTable.RefreshStatus.ACTIVATED
- == oldMaterializedTable.getRefreshStatus()) {
+ if (RefreshStatus.ACTIVATED == oldMaterializedTable.getRefreshStatus()) {
// 1. suspend the materialized table
CatalogMaterializedTable suspendMaterializedTable =
suspendContinuousRefreshJob(
@@ -895,11 +888,10 @@ public class MaterializedTableManager {
tableIdentifier),
e);
}
- } else if (CatalogMaterializedTable.RefreshStatus.SUSPENDED
- == oldMaterializedTable.getRefreshStatus()) {
+ } else if (RefreshStatus.SUSPENDED == oldMaterializedTable.getRefreshStatus()) {
// alter schema & definition query & refresh handler (reset savepoint path of refresh
// handler)
- List<MaterializedTableChange> tableChanges = new ArrayList<>(op.getTableChanges());
+ List<TableChange> tableChanges = new ArrayList<>(op.getTableChanges());
TableChange.ModifyRefreshHandler modifyRefreshHandler =
generateResetSavepointTableChange(
oldMaterializedTable.getSerializedRefreshHandler());
@@ -930,8 +922,8 @@ public class MaterializedTableManager {
private AlterMaterializedTableChangeOperation generateRollbackAlterMaterializedTableOperation(
CatalogMaterializedTable oldMaterializedTable,
AlterMaterializedTableChangeOperation op) {
- List<MaterializedTableChange> tableChanges = op.getTableChanges();
- List<MaterializedTableChange> rollbackChanges = new ArrayList<>();
+ List<TableChange> tableChanges = op.getTableChanges();
+ List<TableChange> rollbackChanges = new ArrayList<>();
for (TableChange tableChange : tableChanges) {
if (tableChange instanceof TableChange.AddColumn) {
@@ -995,18 +987,17 @@ public class MaterializedTableManager {
ResolvedCatalogMaterializedTable materializedTable =
getCatalogMaterializedTable(operationExecutor, tableIdentifier);
- CatalogMaterializedTable.RefreshStatus refreshStatus = materializedTable.getRefreshStatus();
- if (CatalogMaterializedTable.RefreshStatus.ACTIVATED == refreshStatus
- || CatalogMaterializedTable.RefreshStatus.SUSPENDED == refreshStatus) {
- CatalogMaterializedTable.RefreshMode refreshMode = materializedTable.getRefreshMode();
- if (CatalogMaterializedTable.RefreshMode.FULL == refreshMode) {
+ RefreshStatus refreshStatus = materializedTable.getRefreshStatus();
+ if (RefreshStatus.ACTIVATED == refreshStatus || RefreshStatus.SUSPENDED == refreshStatus) {
+ RefreshMode refreshMode = materializedTable.getRefreshMode();
+ if (RefreshMode.FULL == refreshMode) {
deleteRefreshWorkflow(tableIdentifier, materializedTable);
- } else if (CatalogMaterializedTable.RefreshMode.CONTINUOUS == refreshMode
- && CatalogMaterializedTable.RefreshStatus.ACTIVATED == refreshStatus) {
+ } else if (RefreshMode.CONTINUOUS == refreshMode
+ && RefreshStatus.ACTIVATED == refreshStatus) {
cancelContinuousRefreshJob(
operationExecutor, handle, tableIdentifier, materializedTable);
}
- } else if (CatalogMaterializedTable.RefreshStatus.INITIALIZING == refreshStatus) {
+ } else if (RefreshStatus.INITIALIZING == refreshStatus) {
throw new ValidationException(
String.format(
"Current refresh status of materialized table %s is initializing, skip the drop operation.",
@@ -1211,13 +1202,13 @@ public class MaterializedTableManager {
OperationHandle operationHandle,
ObjectIdentifier materializedTableIdentifier,
CatalogMaterializedTable catalogMaterializedTable,
- CatalogMaterializedTable.RefreshStatus refreshStatus,
+ RefreshStatus refreshStatus,
String refreshHandlerSummary,
byte[] serializedRefreshHandler) {
CatalogMaterializedTable updatedMaterializedTable =
catalogMaterializedTable.copy(
refreshStatus, refreshHandlerSummary, serializedRefreshHandler);
- List<MaterializedTableChange> tableChanges = new ArrayList<>();
+ List<TableChange> tableChanges = new ArrayList<>();
tableChanges.add(TableChange.modifyRefreshStatus(refreshStatus));
tableChanges.add(
TableChange.modifyRefreshHandler(refreshHandlerSummary, serializedRefreshHandler));
diff --git a/flink-table/flink-sql-gateway/src/test/java/org/apache/flink/table/gateway/service/MaterializedTableStatementITCase.java b/flink-table/flink-sql-gateway/src/test/java/org/apache/flink/table/gateway/service/MaterializedTableStatementITCase.java
index 32f119bd28e..31564138b61 100644
--- a/flink-table/flink-sql-gateway/src/test/java/org/apache/flink/table/gateway/service/MaterializedTableStatementITCase.java
+++ b/flink-table/flink-sql-gateway/src/test/java/org/apache/flink/table/gateway/service/MaterializedTableStatementITCase.java
@@ -34,8 +34,9 @@ import org.apache.flink.runtime.rest.messages.checkpoints.CheckpointingStatistic
import org.apache.flink.runtime.rest.util.RestMapperUtils;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.ValidationException;
-import org.apache.flink.table.catalog.CatalogMaterializedTable;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.LogicalRefreshMode;
import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshStatus;
import org.apache.flink.table.catalog.Column;
import org.apache.flink.table.catalog.IntervalFreshness;
import org.apache.flink.table.catalog.ObjectIdentifier;
@@ -65,6 +66,7 @@ import org.quartz.JobKey;
import org.quartz.Trigger;
import org.quartz.TriggerKey;
+import java.io.IOException;
import java.nio.file.Path;
import java.time.Duration;
import java.util.ArrayList;
@@ -116,21 +118,13 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, DATE_FORMAT(order_created_at, 'yyyy-MM-dd') AS ds, payment_amount_cents FROM datagenSource"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
// validate materialized table: schema, refresh mode, refresh status, refresh handler,
// doesn't check the data because it generates randomly.
- ResolvedCatalogMaterializedTable actualMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable actualMaterializedTable = getTable(userShopsIdentifier);
// Expected schema
ResolvedSchema expectedSchema =
@@ -144,26 +138,21 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
assertThat(actualMaterializedTable.getResolvedSchema()).isEqualTo(expectedSchema);
assertThat(actualMaterializedTable.getLogicalRefreshMode())
- .isEqualTo(CatalogMaterializedTable.LogicalRefreshMode.AUTOMATIC);
- assertThat(actualMaterializedTable.getRefreshMode())
- .isEqualTo(CatalogMaterializedTable.RefreshMode.CONTINUOUS);
- assertThat(actualMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.ACTIVATED);
+ .isSameAs(LogicalRefreshMode.AUTOMATIC);
+ assertThat(actualMaterializedTable.getRefreshMode()).isSameAs(RefreshMode.CONTINUOUS);
+ assertThat(actualMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.ACTIVATED);
assertThat(actualMaterializedTable.getRefreshHandlerDescription()).isNotEmpty();
assertThat(actualMaterializedTable.getSerializedRefreshHandler()).isNotEmpty();
ContinuousRefreshHandler activeRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- actualMaterializedTable.getSerializedRefreshHandler(),
- getClass().getClassLoader());
+ getContinuousRefreshHandler(actualMaterializedTable);
waitUntilAllTasksAreRunning(
restClusterClient, JobID.fromHexString(activeRefreshHandler.getJobId()));
// verify the background job is running
String describeJobDDL = String.format("DESCRIBE JOB '%s'", activeRefreshHandler.getJobId());
- OperationHandle describeJobHandle =
- service.executeStatement(sessionHandle, describeJobDDL, -1, new Configuration());
+ OperationHandle describeJobHandle = executeStatement(describeJobDDL);
awaitOperationTermination(service, sessionHandle, describeJobHandle);
List<RowData> jobResults = fetchAllResults(service, sessionHandle, describeJobHandle);
assertThat(jobResults.get(0).getString(2).toString()).isEqualTo("RUNNING");
@@ -174,8 +163,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
assertThat(checkpointInterval).isEqualTo(30 * 1000);
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
@@ -197,21 +185,13 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, DATE_FORMAT(order_created_at, 'yyyy-MM-dd') AS ds, payment_amount_cents FROM datagenSource"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
// validate materialized table: schema, refresh mode, refresh status, refresh handler,
// doesn't check the data because it generates randomly.
- ResolvedCatalogMaterializedTable actualMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable actualMaterializedTable = getTable(userShopsIdentifier);
// Expected schema
ResolvedSchema expectedSchema =
@@ -225,10 +205,9 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
assertThat(actualMaterializedTable.getResolvedSchema()).isEqualTo(expectedSchema);
assertThat(actualMaterializedTable.getLogicalRefreshMode())
- .isEqualTo(CatalogMaterializedTable.LogicalRefreshMode.FULL);
- assertThat(actualMaterializedTable.getRefreshMode()).isEqualTo(RefreshMode.FULL);
- assertThat(actualMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.ACTIVATED);
+ .isSameAs(LogicalRefreshMode.FULL);
+ assertThat(actualMaterializedTable.getRefreshMode()).isSameAs(RefreshMode.FULL);
+ assertThat(actualMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.ACTIVATED);
assertThat(actualMaterializedTable.getRefreshHandlerDescription()).isNotEmpty();
assertThat(actualMaterializedTable.getSerializedRefreshHandler()).isNotEmpty();
@@ -238,13 +217,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
EmbeddedRefreshHandlerSerializer.INSTANCE.deserialize(
serializedHandler, getClass().getClassLoader());
assertThat(embeddedRefreshHandler.getWorkflowName())
- .isEqualTo(
- "quartz_job_"
- + ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")
- .asSerializableString());
+ .isEqualTo("quartz_job_" + userShopsIdentifier.asSerializableString());
EmbeddedQuartzScheduler embeddedWorkflowScheduler =
SQL_GATEWAY_REST_ENDPOINT_EXTENSION
@@ -273,8 +246,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.doesNotContainKey(RESOURCES_DOWNLOAD_DIR.key());
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
@@ -296,21 +268,13 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, DATE_FORMAT(order_created_at, 'yyyy-MM-dd') AS ds, payment_amount_cents FROM datagenSource"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
// validate materialized table: schema, refresh mode, refresh status, refresh handler,
// doesn't check the data because it generates randomly.
- ResolvedCatalogMaterializedTable actualMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable actualMaterializedTable = getTable(userShopsIdentifier);
// Expected schema
ResolvedSchema expectedSchema =
@@ -326,26 +290,21 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
assertThat(actualMaterializedTable.getDefinitionFreshness())
.isEqualTo(IntervalFreshness.ofMinute("3"));
assertThat(actualMaterializedTable.getLogicalRefreshMode())
- .isEqualTo(CatalogMaterializedTable.LogicalRefreshMode.AUTOMATIC);
- assertThat(actualMaterializedTable.getRefreshMode())
- .isEqualTo(CatalogMaterializedTable.RefreshMode.CONTINUOUS);
- assertThat(actualMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.ACTIVATED);
+ .isSameAs(LogicalRefreshMode.AUTOMATIC);
+ assertThat(actualMaterializedTable.getRefreshMode()).isSameAs(RefreshMode.CONTINUOUS);
+ assertThat(actualMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.ACTIVATED);
assertThat(actualMaterializedTable.getRefreshHandlerDescription()).isNotEmpty();
assertThat(actualMaterializedTable.getSerializedRefreshHandler()).isNotEmpty();
ContinuousRefreshHandler activeRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- actualMaterializedTable.getSerializedRefreshHandler(),
- getClass().getClassLoader());
+ getContinuousRefreshHandler(actualMaterializedTable);
waitUntilAllTasksAreRunning(
restClusterClient, JobID.fromHexString(activeRefreshHandler.getJobId()));
// verify the background job is running
String describeJobDDL = String.format("DESCRIBE JOB '%s'", activeRefreshHandler.getJobId());
- OperationHandle describeJobHandle =
- service.executeStatement(sessionHandle, describeJobDDL, -1, new Configuration());
+ OperationHandle describeJobHandle = executeStatement(describeJobDDL);
awaitOperationTermination(service, sessionHandle, describeJobHandle);
List<RowData> jobResults = fetchAllResults(service, sessionHandle, describeJobHandle);
assertThat(jobResults.get(0).getString(2).toString()).isEqualTo("RUNNING");
@@ -359,8 +318,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
assertThat(checkpointInterval).isEqualTo(expectedCheckpointInterval);
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
@@ -397,24 +355,14 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, DATE_FORMAT(order_created_at, 'yyyy-MM-dd') AS ds, payment_amount_cents FROM datagenSource"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
- ResolvedCatalogMaterializedTable actualMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable actualMaterializedTable = getTable(userShopsIdentifier);
ContinuousRefreshHandler activeRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- actualMaterializedTable.getSerializedRefreshHandler(),
- getClass().getClassLoader());
+ getContinuousRefreshHandler(actualMaterializedTable);
waitUntilAllTasksAreRunning(
restClusterClient, JobID.fromHexString(activeRefreshHandler.getJobId()));
@@ -424,13 +372,12 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
assertThat(actualCheckpointInterval).isEqualTo(checkpointInterval);
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
void testCreateMaterializedTableInFullMode() throws Exception {
- String dataId = TestValuesTableFactory.registerData(Collections.emptyList());
+ String dataId = TestValuesTableFactory.registerData(List.of());
String sourceDdl =
String.format(
"CREATE TABLE IF NOT EXISTS my_source (\n"
@@ -446,8 +393,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ ")",
dataId);
- OperationHandle sourceHandle =
- service.executeStatement(sessionHandle, sourceDdl, -1, new Configuration());
+ OperationHandle sourceHandle = executeStatement(sourceDdl);
awaitOperationTermination(service, sessionHandle, sourceHandle);
String materializedTableDDL =
@@ -468,24 +414,15 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, order_created_at AS ds, order_id FROM my_source"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
// verify materialized table is created
- ResolvedCatalogMaterializedTable actualMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable actualMaterializedTable = getTable(userShopsIdentifier);
// verify refresh mode
- assertThat(actualMaterializedTable.getRefreshMode())
- .isEqualTo(CatalogMaterializedTable.RefreshMode.FULL);
+ assertThat(actualMaterializedTable.getRefreshMode()).isSameAs(RefreshMode.FULL);
// verify refresh handler
byte[] serializedHandler = actualMaterializedTable.getSerializedRefreshHandler();
@@ -493,13 +430,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
EmbeddedRefreshHandlerSerializer.INSTANCE.deserialize(
serializedHandler, getClass().getClassLoader());
assertThat(embeddedRefreshHandler.getWorkflowName())
- .isEqualTo(
- "quartz_job_"
- + ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")
- .asSerializableString());
+ .isEqualTo("quartz_job_" + userShopsIdentifier.asSerializableString());
EmbeddedQuartzScheduler embeddedWorkflowScheduler =
SQL_GATEWAY_REST_ENDPOINT_EXTENSION
@@ -528,8 +459,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.doesNotContainKey(RESOURCES_DOWNLOAD_DIR.key());
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
@@ -552,10 +482,9 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, DATE_FORMAT(order_created_at, 'yyyy-MM-dd') AS ds, payment_amount_cents FROM datagenSource"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
assertThatThrownBy(
() ->
awaitOperationTermination(
@@ -564,21 +493,10 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessageContaining(
String.format(
"Submit continuous refresh job for materialized table %s occur exception.",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")
- .asSerializableString()));
+ userShopsIdentifier.asSerializableString()));
// verify the materialized table is not created
- assertThatThrownBy(
- () ->
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")))
+ assertThatThrownBy(() -> getTable(userShopsIdentifier))
.isInstanceOf(SqlGatewayException.class)
.hasMessageContaining("Failed to getTable.");
}
@@ -605,8 +523,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
long currentTime = System.currentTimeMillis();
String alterStatement =
"ALTER MATERIALIZED TABLE my_materialized_table REFRESH PARTITION (ds = '2024-01-02')";
- OperationHandle alterHandle =
- service.executeStatement(sessionHandle, alterStatement, -1, new Configuration());
+ OperationHandle alterHandle = executeStatement(alterStatement);
awaitOperationTermination(service, sessionHandle, alterHandle);
List<RowData> result = fetchAllResults(service, sessionHandle, alterHandle);
assertThat(result.size()).isEqualTo(1);
@@ -631,9 +548,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.isEqualTo(1);
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(
- fileSystemCatalogName, TEST_DEFAULT_DATABASE, "my_materialized_table"));
+ dropMaterializedTable(getObjectIdentifier("my_materialized_table"));
}
@Test
@@ -657,11 +572,10 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds1, ds2)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
// CASE 1: check unknown partition keys
String alterStatementWithUnknownPartitionKey =
"ALTER MATERIALIZED TABLE users_shops REFRESH PARTITION (ds3 = '2024-01-01')";
@@ -716,8 +630,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ "ds2");
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
@@ -741,27 +654,16 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
- ResolvedCatalogMaterializedTable activeMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable activeMaterializedTable = getTable(userShopsIdentifier);
- assertThat(activeMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.ACTIVATED);
+ assertThat(activeMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.ACTIVATED);
ContinuousRefreshHandler activeRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- activeMaterializedTable.getSerializedRefreshHandler(),
- getClass().getClassLoader());
+ getContinuousRefreshHandler(activeMaterializedTable);
waitUntilAllTasksAreRunning(
restClusterClient, JobID.fromHexString(activeRefreshHandler.getJobId()));
@@ -772,39 +674,26 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
String.format(
"SET 'execution.checkpointing.savepoint-dir' = 'file://%s'", savepointDir);
OperationHandle alterMaterializedTableSavepointHandle =
- service.executeStatement(
- sessionHandle, alterJobSavepointDDL, -1, new Configuration());
+ executeStatement(alterJobSavepointDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableSavepointHandle);
// suspend materialized table
String alterMaterializedTableSuspendDDL = "ALTER MATERIALIZED TABLE users_shops SUSPEND";
OperationHandle alterMaterializedTableSuspendHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableSuspendDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableSuspendDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableSuspendHandle);
- ResolvedCatalogMaterializedTable suspendMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable suspendMaterializedTable = getTable(userShopsIdentifier);
- assertThat(suspendMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.SUSPENDED);
+ assertThat(suspendMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.SUSPENDED);
// verify background job is stopped
- byte[] refreshHandler = suspendMaterializedTable.getSerializedRefreshHandler();
ContinuousRefreshHandler suspendRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- refreshHandler, getClass().getClassLoader());
+ getContinuousRefreshHandler(suspendMaterializedTable);
String suspendJobId = suspendRefreshHandler.getJobId();
String describeJobDDL = String.format("DESCRIBE JOB '%s'", suspendJobId);
- OperationHandle describeJobHandle =
- service.executeStatement(sessionHandle, describeJobDDL, -1, new Configuration());
+ OperationHandle describeJobHandle = executeStatement(describeJobDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableSuspendHandle);
List<RowData> jobResults = fetchAllResults(service, sessionHandle, describeJobHandle);
assertThat(jobResults.get(0).getString(2).toString()).isEqualTo("FINISHED");
@@ -817,43 +706,27 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
String alterMaterializedTableResumeDDL =
"ALTER MATERIALIZED TABLE users_shops RESUME WITH ('debezium-json.ignore-parse-errors' = 'true')";
OperationHandle alterMaterializedTableResumeHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableResumeDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableResumeDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableResumeHandle);
ResolvedCatalogMaterializedTable resumedCatalogMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ getTable(userShopsIdentifier);
assertThat(resumedCatalogMaterializedTable.getOptions())
.doesNotContainKey("debezium-json.ignore-parse-errors");
assertThat(resumedCatalogMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.ACTIVATED);
+ .isSameAs(RefreshStatus.ACTIVATED);
waitUntilAllTasksAreRunning(
restClusterClient,
JobID.fromHexString(
- ContinuousRefreshHandlerSerializer.INSTANCE
- .deserialize(
- resumedCatalogMaterializedTable
- .getSerializedRefreshHandler(),
- getClass().getClassLoader())
- .getJobId()));
+ getContinuousRefreshHandler(resumedCatalogMaterializedTable).getJobId()));
// verify background job is running
- refreshHandler = resumedCatalogMaterializedTable.getSerializedRefreshHandler();
ContinuousRefreshHandler resumeRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- refreshHandler, getClass().getClassLoader());
+ getContinuousRefreshHandler(resumedCatalogMaterializedTable);
String resumeJobId = resumeRefreshHandler.getJobId();
String describeResumeJobDDL = String.format("DESCRIBE JOB '%s'", resumeJobId);
- OperationHandle describeResumeJobHandle =
- service.executeStatement(
- sessionHandle, describeResumeJobDDL, -1, new Configuration());
+ OperationHandle describeResumeJobHandle = executeStatement(describeResumeJobDDL);
awaitOperationTermination(service, sessionHandle, describeResumeJobHandle);
jobResults = fetchAllResults(service, sessionHandle, describeResumeJobHandle);
assertThat(jobResults.get(0).getString(2).toString()).isEqualTo("RUNNING");
@@ -865,8 +738,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
assertThat(actualRestorePath.get()).isEqualTo(actualSavepointPath);
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
@@ -890,19 +762,11 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
- ResolvedCatalogMaterializedTable activeMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable activeMaterializedTable = getTable(userShopsIdentifier);
waitUntilAllTasksAreRunning(
restClusterClient,
JobID.fromHexString(
@@ -915,8 +779,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
// suspend materialized table
String alterMaterializedTableSuspendDDL = "ALTER MATERIALIZED TABLE users_shops SUSPEND";
OperationHandle alterMaterializedTableSuspendHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableSuspendDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableSuspendDDL);
assertThatThrownBy(
() ->
awaitOperationTermination(
@@ -929,8 +792,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
"Savepoint directory is not configured, can't stop job with savepoint.");
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
@@ -954,19 +816,11 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
- ResolvedCatalogMaterializedTable activeMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable activeMaterializedTable = getTable(userShopsIdentifier);
waitUntilAllTasksAreRunning(
restClusterClient,
JobID.fromHexString(
@@ -982,21 +836,18 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
String.format(
"SET 'execution.checkpointing.savepoint-dir' = 'file://%s'", savepointDir);
OperationHandle alterMaterializedTableSavepointHandle =
- service.executeStatement(
- sessionHandle, alterJobSavepointDDL, -1, new Configuration());
+ executeStatement(alterJobSavepointDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableSavepointHandle);
// suspend materialized table
String alterMaterializedTableSuspendDDL = "ALTER MATERIALIZED TABLE users_shops SUSPEND";
OperationHandle alterMaterializedTableSuspendHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableSuspendDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableSuspendDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableSuspendHandle);
// verify repeated suspend materialized table
OperationHandle repeatedAlterMaterializedTableSuspendHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableSuspendDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableSuspendDDL);
assertThatThrownBy(
() ->
awaitOperationTermination(
@@ -1008,22 +859,17 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessageContaining(
String.format(
"Materialized table %s continuous refresh job has been suspended",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")));
+ userShopsIdentifier));
// resume materialized table
String alterMaterializedTableResumeDDL = "ALTER MATERIALIZED TABLE users_shops RESUME";
OperationHandle alterMaterializedTableResumeHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableResumeDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableResumeDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableResumeHandle);
// verify repeated resume materialized table
OperationHandle repeatedAlterMaterializedTableResumeHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableResumeDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableResumeDDL);
assertThatThrownBy(
() ->
awaitOperationTermination(
@@ -1035,48 +881,29 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessageContaining(
String.format(
"Materialized table %s continuous refresh job has been resumed",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")));
+ userShopsIdentifier));
}
@Test
void testAlterMaterializedTableSuspendAndResumeInFullMode() throws Exception {
createAndVerifyCreateMaterializedTableWithData(
- "users_shops", Collections.emptyList(), Collections.emptyMap(), RefreshMode.FULL);
+ "users_shops", List.of(), Map.of(), RefreshMode.FULL);
- ResolvedCatalogMaterializedTable activeMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable activeMaterializedTable = getTable(userShopsIdentifier);
- assertThat(activeMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.ACTIVATED);
+ assertThat(activeMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.ACTIVATED);
// suspend materialized table
String alterMaterializedTableSuspendDDL = "ALTER MATERIALIZED TABLE users_shops SUSPEND";
OperationHandle alterMaterializedTableSuspendHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableSuspendDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableSuspendDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableSuspendHandle);
- ResolvedCatalogMaterializedTable suspendMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable suspendMaterializedTable = getTable(userShopsIdentifier);
- assertThat(suspendMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.SUSPENDED);
+ assertThat(suspendMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.SUSPENDED);
// verify workflow is suspended
byte[] refreshHandler = suspendMaterializedTable.getSerializedRefreshHandler();
@@ -1102,21 +929,14 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
String alterMaterializedTableResumeDDL =
"ALTER MATERIALIZED TABLE users_shops RESUME WITH ('debezium-json.ignore-parse-errors' = 'true')";
OperationHandle alterMaterializedTableResumeHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableResumeDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableResumeDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableResumeHandle);
ResolvedCatalogMaterializedTable resumedCatalogMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ getTable(userShopsIdentifier);
assertThat(resumedCatalogMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.ACTIVATED);
+ .isSameAs(RefreshStatus.ACTIVATED);
// verify workflow is resumed
refreshHandler = resumedCatalogMaterializedTable.getSerializedRefreshHandler();
@@ -1140,38 +960,28 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.containsEntry("debezium-json.ignore-parse-errors", "true");
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
void testAlterMaterializedTableWithRepeatedSuspendAndResumeInFullMode() throws Exception {
createAndVerifyCreateMaterializedTableWithData(
- "users_shops", Collections.emptyList(), Collections.emptyMap(), RefreshMode.FULL);
+ "users_shops", List.of(), Map.of(), RefreshMode.FULL);
- ResolvedCatalogMaterializedTable activeMaterializedTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable activeMaterializedTable = getTable(userShopsIdentifier);
- assertThat(activeMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.ACTIVATED);
+ assertThat(activeMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.ACTIVATED);
// suspend materialized table
String alterMaterializedTableSuspendDDL = "ALTER MATERIALIZED TABLE users_shops SUSPEND";
OperationHandle alterMaterializedTableSuspendHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableSuspendDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableSuspendDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableSuspendHandle);
// repeated suspend materialized table
OperationHandle repeatedAlterMaterializedTableSuspendHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableSuspendDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableSuspendDDL);
assertThatThrownBy(
() ->
awaitOperationTermination(
@@ -1183,23 +993,18 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessageContaining(
String.format(
"Materialized table %s refresh workflow has been suspended.",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")));
+ userShopsIdentifier));
// resume materialized table
String alterMaterializedTableResumeDDL =
"ALTER MATERIALIZED TABLE users_shops RESUME WITH ('debezium-json.ignore-parse-errors' = 'true')";
OperationHandle alterMaterializedTableResumeHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableResumeDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableResumeDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableResumeHandle);
// verify repeated resume materialized table
OperationHandle repeatedAlterMaterializedTableResumeHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableResumeDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableResumeDDL);
assertThatThrownBy(
() ->
awaitOperationTermination(
@@ -1211,28 +1016,51 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessageContaining(
String.format(
"Materialized table %s refresh workflow has been resumed.",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")));
+ userShopsIdentifier));
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
+ }
+
+ @Test
+ void testAlterMaterializedTableAddVirtualColumnsFullMode() throws Exception {
+ createAndVerifyCreateMaterializedTableWithData(
+ "users_shops", List.of(), Map.of(), RefreshMode.FULL);
+
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable oldTable = getTable(userShopsIdentifier);
+
+ // Alter materialized table as query in full mode
+ String alterMaterializedTableAsQueryDDL =
+ "ALTER MATERIALIZED TABLE users_shops ADD (`ct` AS CURRENT_TIMESTAMP, WATERMARK FOR `ct` AS `ct` - INTERVAL '3' SECOND)";
+
+ OperationHandle alterMaterializedTableAsQueryHandle =
+ executeStatement(alterMaterializedTableAsQueryDDL);
+
+ awaitOperationTermination(service, sessionHandle, alterMaterializedTableAsQueryHandle);
+
+ // verify the altered materialized table
+ ResolvedCatalogMaterializedTable newTable = getTable(userShopsIdentifier);
+
+ ResolvedSchema newSchema = newTable.getResolvedSchema();
+ assertThat(getAddedColumns(newSchema, oldTable.getResolvedSchema()))
+ .hasToString("[`ct` TIMESTAMP_LTZ(3) NOT NULL *ROWTIME* AS CURRENT_TIMESTAMP]");
+ assertThat(newSchema.getWatermarkSpecs())
+ .hasToString(
+ "[WATERMARK FOR `ct`: TIMESTAMP_LTZ(3) NOT NULL AS `ct` - INTERVAL '3' SECOND]");
+ assertThat(newTable.getExpandedQuery()).isEqualTo(oldTable.getExpandedQuery());
+ // the refresh handler in full mode should be the same as the old one
+ assertThat(oldTable.getSerializedRefreshHandler())
+ .isEqualTo(newTable.getSerializedRefreshHandler());
+ assertThat(oldTable.getDefinitionFreshness()).isEqualTo(newTable.getDefinitionFreshness());
}
@Test
void testAlterMaterializedTableAsQueryInFullMode() throws Exception {
createAndVerifyCreateMaterializedTableWithData(
- "users_shops", Collections.emptyList(), Collections.emptyMap(), RefreshMode.FULL);
+ "users_shops", List.of(), Map.of(), RefreshMode.FULL);
- ResolvedCatalogMaterializedTable oldTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable oldTable = getTable(userShopsIdentifier);
// Alter materialized table as query in full mode
String alterMaterializedTableAsQueryDDL =
@@ -1249,25 +1077,15 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " GROUP BY (user_id, shop_id, ds)";
OperationHandle alterMaterializedTableAsQueryHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableAsQueryDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableAsQueryDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableAsQueryHandle);
// verify the altered materialized table
- ResolvedCatalogMaterializedTable newTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable newTable = getTable(userShopsIdentifier);
assertThat(getAddedColumns(newTable.getResolvedSchema(), oldTable.getResolvedSchema()))
- .isEqualTo(
- Collections.singletonList(
- Column.physical("order_amount_sum", DataTypes.INT())));
+ .isEqualTo(List.of(Column.physical("order_amount_sum", DataTypes.INT())));
assertThat(newTable.getExpandedQuery())
.isEqualTo(
String.format(
@@ -1293,9 +1111,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " )\n"
+ " FRESHNESS = INTERVAL '30' SECOND\n"
+ " AS SELECT 1 as shop_id, 2 as user_id";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
assertThatThrownBy(
() ->
awaitOperationTermination(
@@ -1311,36 +1127,22 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
@Test
void testAlterMaterializedTableAddDistribution() throws Exception {
createAndVerifyCreateMaterializedTableWithData(
- "users_shops", Collections.emptyList(), Collections.emptyMap(), RefreshMode.FULL);
+ "users_shops", List.of(), Map.of(), RefreshMode.FULL);
- ResolvedCatalogMaterializedTable oldTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable oldTable = getTable(userShopsIdentifier);
// Alter materialized table as query in full mode
String alterMaterializedTableAsQueryDDL =
"ALTER MATERIALIZED TABLE users_shops ADD DISTRIBUTION BY HASH (`order_id`) INTO 2 BUCKETS";
OperationHandle alterMaterializedTableAsQueryHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableAsQueryDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableAsQueryDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableAsQueryHandle);
// verify the altered materialized table
- ResolvedCatalogMaterializedTable newTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable newTable = getTable(userShopsIdentifier);
assertThat(newTable.getExpandedQuery()).isEqualTo(oldTable.getExpandedQuery());
@@ -1356,22 +1158,15 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
@Test
void testAlterMaterializedTableAsQueryInFullModeWithSuspendStatus() throws Exception {
createAndVerifyCreateMaterializedTableWithData(
- "users_shops", Collections.emptyList(), Collections.emptyMap(), RefreshMode.FULL);
+ "users_shops", List.of(), Map.of(), RefreshMode.FULL);
- ResolvedCatalogMaterializedTable oldTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable oldTable = getTable(userShopsIdentifier);
// Alter materialized table suspend
String alterMaterializedTableSuspendDDL = "ALTER MATERIALIZED TABLE users_shops SUSPEND";
OperationHandle alterMaterializedTableSuspendHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableSuspendDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableSuspendDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableSuspendHandle);
// Alter materialized table as query in full mode
@@ -1389,25 +1184,15 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " GROUP BY (user_id, shop_id, ds)";
OperationHandle alterMaterializedTableAsQueryHandle =
- service.executeStatement(
- sessionHandle, alterMaterializedTableAsQueryDDL, -1, new Configuration());
+ executeStatement(alterMaterializedTableAsQueryDDL);
awaitOperationTermination(service, sessionHandle, alterMaterializedTableAsQueryHandle);
// verify the altered materialized table
- ResolvedCatalogMaterializedTable newTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable newTable = getTable(userShopsIdentifier);
assertThat(getAddedColumns(newTable.getResolvedSchema(), oldTable.getResolvedSchema()))
- .isEqualTo(
- Collections.singletonList(
- Column.physical("order_amount_sum", DataTypes.INT())));
+ .containsExactly(Column.physical("order_amount_sum", DataTypes.INT()));
assertThat(newTable.getExpandedQuery())
.isEqualTo(
String.format(
@@ -1443,23 +1228,13 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, DATE_FORMAT(order_created_at, 'yyyy-MM-dd') AS ds, payment_amount_cents FROM datagenSource"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
- ResolvedCatalogMaterializedTable oldTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable oldTable = getTable(userShopsIdentifier);
// verify background job is running
- ContinuousRefreshHandler activeRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- oldTable.getSerializedRefreshHandler(), getClass().getClassLoader());
+ ContinuousRefreshHandler activeRefreshHandler = getContinuousRefreshHandler(oldTable);
waitUntilAllTasksAreRunning(
restClusterClient, JobID.fromHexString(activeRefreshHandler.getJobId()));
@@ -1477,26 +1252,18 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, DATE_FORMAT(order_created_at, 'yyyy-MM-dd') AS ds, payment_amount_cents FROM datagenSource"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle alterTableHandle =
- service.executeStatement(sessionHandle, alterTableDDL, -1, new Configuration());
+ OperationHandle alterTableHandle = executeStatement(alterTableDDL);
awaitOperationTermination(service, sessionHandle, alterTableHandle);
- ResolvedCatalogMaterializedTable newTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable newTable = getTable(userShopsIdentifier);
assertThat(getAddedColumns(newTable.getResolvedSchema(), oldTable.getResolvedSchema()))
- .isEqualTo(Collections.singletonList(Column.physical("pv", DataTypes.INT())));
+ .containsExactly(Column.physical("pv", DataTypes.INT()));
assertThat(newTable.getResolvedSchema().getPrimaryKey())
.isEqualTo(oldTable.getResolvedSchema().getPrimaryKey());
assertThat(newTable.getResolvedSchema().getWatermarkSpecs())
.isEqualTo(oldTable.getResolvedSchema().getWatermarkSpecs());
assertThat(newTable.getExpandedQuery())
- .isEqualTo(
+ .hasToString(
String.format(
"SELECT COALESCE(`tmp`.`user_id`, CAST(0 AS BIGINT)) AS `user_id`, `tmp`.`shop_id`, COALESCE(`tmp`.`ds`, '') AS `ds`, SUM(`tmp`.`payment_amount_cents`) AS `payed_buy_fee_sum`, SUM(1) AS `pv`\n"
+ "FROM (SELECT `datagenSource`.`user_id`, `datagenSource`.`shop_id`, DATE_FORMAT(`datagenSource`.`order_created_at`, 'yyyy-MM-dd') AS `ds`, `datagenSource`.`payment_amount_cents`\n"
@@ -1508,17 +1275,14 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
// verify the new continuous job is start without savepoint
ContinuousRefreshHandler newContinuousRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- newTable.getSerializedRefreshHandler(),
- Thread.currentThread().getContextClassLoader());
+ getContinuousRefreshHandler(newTable);
Optional<String> restorePath =
getJobRestoreSavepointPath(
restClusterClient, newContinuousRefreshHandler.getJobId());
assertThat(restorePath).isEmpty();
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
@@ -1540,23 +1304,13 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, DATE_FORMAT(order_created_at, 'yyyy-MM-dd') AS ds, payment_amount_cents FROM datagenSource"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
- ResolvedCatalogMaterializedTable oldTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ ResolvedCatalogMaterializedTable oldTable = getTable(userShopsIdentifier);
// verify background job is running
- ContinuousRefreshHandler activeRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- oldTable.getSerializedRefreshHandler(), getClass().getClassLoader());
+ ContinuousRefreshHandler activeRefreshHandler = getContinuousRefreshHandler(oldTable);
waitUntilAllTasksAreRunning(
restClusterClient, JobID.fromHexString(activeRefreshHandler.getJobId()));
@@ -1564,8 +1318,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
// suspend materialized table
String suspendTableDDL = "ALTER MATERIALIZED TABLE users_shops SUSPEND";
- OperationHandle suspendTableHandle =
- service.executeStatement(sessionHandle, suspendTableDDL, -1, new Configuration());
+ OperationHandle suspendTableHandle = executeStatement(suspendTableDDL);
awaitOperationTermination(service, sessionHandle, suspendTableHandle);
String alterTableDDL =
@@ -1580,22 +1333,14 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " SELECT user_id, shop_id, DATE_FORMAT(order_created_at, 'yyyy-MM-dd') AS ds, payment_amount_cents FROM datagenSource"
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle alterTableHandle =
- service.executeStatement(sessionHandle, alterTableDDL, -1, new Configuration());
+ OperationHandle alterTableHandle = executeStatement(alterTableDDL);
awaitOperationTermination(service, sessionHandle, alterTableHandle);
- ResolvedCatalogMaterializedTable newTable =
- (ResolvedCatalogMaterializedTable)
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops"));
+ ResolvedCatalogMaterializedTable newTable = getTable(userShopsIdentifier);
assertThat(getAddedColumns(newTable.getResolvedSchema(), oldTable.getResolvedSchema()))
- .isEqualTo(Collections.singletonList(Column.physical("pv", DataTypes.INT())));
+ .containsExactly(Column.physical("pv", DataTypes.INT()));
assertThat(newTable.getExpandedQuery())
- .isEqualTo(
+ .hasToString(
String.format(
"SELECT `tmp`.`user_id`, `tmp`.`shop_id`, `tmp`.`ds`, SUM(`tmp`.`payment_amount_cents`) AS `payed_buy_fee_sum`, SUM(1) AS `pv`\n"
+ "FROM (SELECT `datagenSource`.`user_id`, `datagenSource`.`shop_id`, DATE_FORMAT(`datagenSource`.`order_created_at`, 'yyyy-MM-dd') AS `ds`, `datagenSource`.`payment_amount_cents`\n"
@@ -1608,14 +1353,11 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
// verify the restore path is empty
ContinuousRefreshHandler newContinuousRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- newTable.getSerializedRefreshHandler(),
- Thread.currentThread().getContextClassLoader());
+ getContinuousRefreshHandler(newTable);
assertThat(newContinuousRefreshHandler.getRestorePath()).isEmpty();
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ dropMaterializedTable(userShopsIdentifier);
}
@Test
@@ -1638,39 +1380,27 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
+ " ) AS tmp\n"
+ " GROUP BY (user_id, shop_id, ds)";
- OperationHandle materializedTableHandle =
- service.executeStatement(
- sessionHandle, materializedTableDDL, -1, new Configuration());
+ OperationHandle materializedTableHandle = executeStatement(materializedTableDDL);
awaitOperationTermination(service, sessionHandle, materializedTableHandle);
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
// verify materialized table exists
- ResolvedCatalogBaseTable<?> activeMaterializedTable =
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName, TEST_DEFAULT_DATABASE, "users_shops"));
+ ResolvedCatalogBaseTable<?> activeMaterializedTable = getTable(userShopsIdentifier);
assertThat(activeMaterializedTable).isInstanceOf(ResolvedCatalogMaterializedTable.class);
+ ResolvedCatalogMaterializedTable activeMaterializedTable1 =
+ (ResolvedCatalogMaterializedTable) activeMaterializedTable;
waitUntilAllTasksAreRunning(
restClusterClient,
JobID.fromHexString(
- ContinuousRefreshHandlerSerializer.INSTANCE
- .deserialize(
- ((ResolvedCatalogMaterializedTable) activeMaterializedTable)
- .getSerializedRefreshHandler(),
- getClass().getClassLoader())
- .getJobId()));
+ getContinuousRefreshHandler(activeMaterializedTable1).getJobId()));
// verify background job is running
ContinuousRefreshHandler activeRefreshHandler =
- ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
- ((ResolvedCatalogMaterializedTable) activeMaterializedTable)
- .getSerializedRefreshHandler(),
- getClass().getClassLoader());
+ getContinuousRefreshHandler(activeMaterializedTable1);
String describeJobDDL = String.format("DESCRIBE JOB '%s'", activeRefreshHandler.getJobId());
- OperationHandle describeJobHandle =
- service.executeStatement(sessionHandle, describeJobDDL, -1, new Configuration());
+ OperationHandle describeJobHandle = executeStatement(describeJobDDL);
awaitOperationTermination(service, sessionHandle, describeJobHandle);
List<RowData> jobResults = fetchAllResults(service, sessionHandle, describeJobHandle);
assertThat(jobResults.get(0).getString(2).toString()).isEqualTo("RUNNING");
@@ -1678,8 +1408,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
// Drop materialized table using drop table statement
String dropTableUsingMaterializedTableDDL = "DROP TABLE users_shops";
OperationHandle dropTableUsingMaterializedTableHandle =
- service.executeStatement(
- sessionHandle, dropTableUsingMaterializedTableDDL, -1, new Configuration());
+ executeStatement(dropTableUsingMaterializedTableDDL);
assertThatThrownBy(
() ->
@@ -1692,28 +1421,15 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessage(
String.format(
"Table with identifier '%s' does not exist.",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")
- .asSummaryString()));
+ userShopsIdentifier.asSummaryString()));
// drop materialized table
String dropMaterializedTableDDL = "DROP MATERIALIZED TABLE IF EXISTS users_shops";
- OperationHandle dropMaterializedTableHandle =
- service.executeStatement(
- sessionHandle, dropMaterializedTableDDL, -1, new Configuration());
+ OperationHandle dropMaterializedTableHandle = executeStatement(dropMaterializedTableDDL);
awaitOperationTermination(service, sessionHandle, dropMaterializedTableHandle);
// verify materialized table metadata is removed
- assertThatThrownBy(
- () ->
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")))
+ assertThatThrownBy(() -> getTable(userShopsIdentifier))
.isInstanceOf(SqlGatewayException.class)
.hasMessageContaining("Failed to getTable.");
@@ -1723,9 +1439,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
String describeJobAfterDropDDL =
String.format("DESCRIBE JOB '%s'", activeRefreshHandler.getJobId());
- OperationHandle describeJobAfterDropHandle =
- service.executeStatement(
- sessionHandle, describeJobAfterDropDDL, -1, new Configuration());
+ OperationHandle describeJobAfterDropHandle = executeStatement(describeJobAfterDropDDL);
awaitOperationTermination(service, sessionHandle, describeJobAfterDropHandle);
List<RowData> jobResultsAfterDrop =
fetchAllResults(service, sessionHandle, describeJobAfterDropHandle);
@@ -1734,8 +1448,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
// verify drop materialized table that doesn't exist
String dropNonExistMaterializedTableDDL = "DROP MATERIALIZED TABLE users_shops";
OperationHandle dropNonExistTableHandle =
- service.executeStatement(
- sessionHandle, dropNonExistMaterializedTableDDL, -1, new Configuration());
+ executeStatement(dropNonExistMaterializedTableDDL);
assertThatThrownBy(
() ->
@@ -1746,50 +1459,32 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessage(
String.format(
"Materialized table with identifier %s does not exist.",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")
- .asSerializableString()));
+ userShopsIdentifier.asSerializableString()));
String dropNonExistMaterializedTableDDL2 = "DROP MATERIALIZED TABLE IF EXISTS users_shops";
OperationHandle dropNonExistMaterializedTableHandle2 =
- service.executeStatement(
- sessionHandle, dropNonExistMaterializedTableDDL2, -1, new Configuration());
+ executeStatement(dropNonExistMaterializedTableDDL2);
awaitOperationTermination(service, sessionHandle, dropNonExistMaterializedTableHandle2);
// Drop a table using drop materialized table statement
dropMaterializedTableDDL = "DROP MATERIALIZED TABLE IF EXISTS datagenSource";
- OperationHandle dropTableHandle =
- service.executeStatement(
- sessionHandle, dropMaterializedTableDDL, -1, new Configuration());
+ OperationHandle dropTableHandle = executeStatement(dropMaterializedTableDDL);
assertThatThrownBy(() -> awaitOperationTermination(service, sessionHandle, dropTableHandle))
.rootCause()
.isInstanceOf(ValidationException.class)
.hasMessage(
String.format(
"Table %s is not a materialized table, does not support materialized table related operation.",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "datagenSource")
- .asSerializableString()));
+ getObjectIdentifier("datagenSource").asSerializableString()));
}
@Test
void testDropMaterializedTableInFullMode() throws Exception {
createAndVerifyCreateMaterializedTableWithData(
- "users_shops", Collections.emptyList(), Collections.emptyMap(), RefreshMode.FULL);
+ "users_shops", List.of(), Map.of(), RefreshMode.FULL);
- JobKey jobKey =
- JobKey.jobKey(
- "quartz_job_"
- + ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")
- .asSerializableString(),
- "default_group");
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ JobKey jobKey = getJobKey(userShopsIdentifier);
EmbeddedQuartzScheduler embeddedWorkflowScheduler =
SQL_GATEWAY_REST_ENDPOINT_EXTENSION
.getSqlGatewayRestEndpoint()
@@ -1801,8 +1496,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
// Drop materialized table using drop table statement
String dropTableUsingMaterializedTableDDL = "DROP TABLE users_shops";
OperationHandle dropTableUsingMaterializedTableHandle =
- service.executeStatement(
- sessionHandle, dropTableUsingMaterializedTableDDL, -1, new Configuration());
+ executeStatement(dropTableUsingMaterializedTableDDL);
assertThatThrownBy(
() ->
@@ -1815,28 +1509,15 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessage(
String.format(
"Table with identifier '%s' does not exist.",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")
- .asSummaryString()));
+ userShopsIdentifier.asSummaryString()));
// drop materialized table
String dropMaterializedTableDDL = "DROP MATERIALIZED TABLE IF EXISTS users_shops";
- OperationHandle dropMaterializedTableHandle =
- service.executeStatement(
- sessionHandle, dropMaterializedTableDDL, -1, new Configuration());
+ OperationHandle dropMaterializedTableHandle = executeStatement(dropMaterializedTableDDL);
awaitOperationTermination(service, sessionHandle, dropMaterializedTableHandle);
// verify materialized table metadata is removed
- assertThatThrownBy(
- () ->
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")))
+ assertThatThrownBy(() -> getTable(userShopsIdentifier))
.isInstanceOf(SqlGatewayException.class)
.hasMessageContaining("Failed to getTable.");
@@ -1847,17 +1528,10 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
@Test
void testDropMaterializedTableWithDeletedRefreshWorkflowInFullMode() throws Exception {
createAndVerifyCreateMaterializedTableWithData(
- "users_shops", Collections.emptyList(), Collections.emptyMap(), RefreshMode.FULL);
+ "users_shops", List.of(), Map.of(), RefreshMode.FULL);
- JobKey jobKey =
- JobKey.jobKey(
- "quartz_job_"
- + ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")
- .asSerializableString(),
- "default_group");
+ ObjectIdentifier userShopsIdentifier = getObjectIdentifier("users_shops");
+ JobKey jobKey = getJobKey(userShopsIdentifier);
EmbeddedQuartzScheduler embeddedWorkflowScheduler =
SQL_GATEWAY_REST_ENDPOINT_EXTENSION
.getSqlGatewayRestEndpoint()
@@ -1871,20 +1545,11 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
// drop materialized table
String dropMaterializedTableDDL = "DROP MATERIALIZED TABLE IF EXISTS users_shops";
- OperationHandle dropMaterializedTableHandle =
- service.executeStatement(
- sessionHandle, dropMaterializedTableDDL, -1, new Configuration());
+ OperationHandle dropMaterializedTableHandle = executeStatement(dropMaterializedTableDDL);
awaitOperationTermination(service, sessionHandle, dropMaterializedTableHandle);
// verify materialized table metadata is removed
- assertThatThrownBy(
- () ->
- service.getTable(
- sessionHandle,
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "users_shops")))
+ assertThatThrownBy(() -> getTable(userShopsIdentifier))
.isInstanceOf(SqlGatewayException.class)
.hasMessageContaining("Failed to getTable.");
}
@@ -1901,9 +1566,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
Collections.singletonMap("ds", "yyyy-MM-dd"),
RefreshMode.CONTINUOUS);
- ObjectIdentifier objectIdentifier =
- ObjectIdentifier.of(
- fileSystemCatalogName, TEST_DEFAULT_DATABASE, "my_materialized_table");
+ ObjectIdentifier objectIdentifier = getObjectIdentifier("my_materialized_table");
// add more data to all data list
data.add(Row.of(3L, 3L, 3L, "2024-01-01"));
@@ -1920,9 +1583,9 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
objectIdentifier.asSerializableString(),
false,
null,
- Collections.emptyMap(),
+ Map.of(),
staticPartitions,
- Collections.emptyMap());
+ Map.of());
awaitOperationTermination(service, sessionHandle, refreshTableHandle);
List<RowData> result = fetchAllResults(service, sessionHandle, refreshTableHandle);
assertThat(result.size()).isEqualTo(1);
@@ -1948,9 +1611,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.isNotEqualTo(getPartitionSize(data, "2024-01-01"));
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(
- fileSystemCatalogName, TEST_DEFAULT_DATABASE, "my_materialized_table"));
+ dropMaterializedTable(objectIdentifier);
}
@Test
@@ -1963,14 +1624,11 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
createAndVerifyCreateMaterializedTableWithData(
"my_materialized_table_without_partition_options",
data,
- Collections.emptyMap(),
+ Map.of(),
RefreshMode.CONTINUOUS);
- ObjectIdentifier materializedTableWithoutFormatterIdentifier =
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "my_materialized_table_without_partition_options");
+ ObjectIdentifier tableWithoutFormatterIdentifier =
+ getObjectIdentifier("my_materialized_table_without_partition_options");
// add more data to all data list
data.add(Row.of(3L, 3L, 3L, "2024-01-01"));
@@ -1980,12 +1638,12 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
OperationHandle periodRefreshTableWithoutFormatterHandle =
service.refreshMaterializedTable(
sessionHandle,
- materializedTableWithoutFormatterIdentifier.asSerializableString(),
+ tableWithoutFormatterIdentifier.asSerializableString(),
true,
"2024-01-02 00:00:00",
- Collections.emptyMap(),
- Collections.emptyMap(),
- Collections.emptyMap());
+ Map.of(),
+ Map.of(),
+ Map.of());
awaitOperationTermination(service, sessionHandle, periodRefreshTableWithoutFormatterHandle);
@@ -2016,11 +1674,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.isEqualTo(getPartitionSize(data, "2024-01-02"));
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "my_materialized_table_without_partition_options"));
+ dropMaterializedTable(tableWithoutFormatterIdentifier);
}
@Test
@@ -2034,9 +1688,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
Collections.singletonMap("ds", "yyyy-MM-dd"),
RefreshMode.FULL);
- ObjectIdentifier materializedTableIdentifier =
- ObjectIdentifier.of(
- fileSystemCatalogName, TEST_DEFAULT_DATABASE, "my_materialized_table");
+ ObjectIdentifier materializedTableIdentifier = getObjectIdentifier("my_materialized_table");
// add more data to all data list
data.add(Row.of(1L, 1L, 1L, "2024-01-01"));
@@ -2051,9 +1703,9 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
materializedTableIdentifier.asSerializableString(),
true,
"2024-01-03 00:00:00",
- Collections.emptyMap(),
- Collections.emptyMap(),
- Collections.emptyMap());
+ Map.of(),
+ Map.of(),
+ Map.of());
awaitOperationTermination(service, sessionHandle, periodRefreshTableHandle);
@@ -2084,9 +1736,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.isNotEqualTo(getPartitionSize(data, "2024-01-01"));
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(
- fileSystemCatalogName, TEST_DEFAULT_DATABASE, "my_materialized_table"));
+ dropMaterializedTable(materializedTableIdentifier);
}
@Test
@@ -2101,9 +1751,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
Collections.singletonMap("ds", "yyyy-MM-dd"),
RefreshMode.CONTINUOUS);
- ObjectIdentifier objectIdentifier =
- ObjectIdentifier.of(
- fileSystemCatalogName, TEST_DEFAULT_DATABASE, "my_materialized_table");
+ ObjectIdentifier objectIdentifier = getObjectIdentifier("my_materialized_table");
// refresh the materialized table with schedule time not specified
OperationHandle invalidRefreshTableHandle1 =
@@ -2112,9 +1760,9 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
objectIdentifier.asSerializableString(),
true,
null,
- Collections.emptyMap(),
- Collections.emptyMap(),
- Collections.emptyMap());
+ Map.of(),
+ Map.of(),
+ Map.of());
assertThatThrownBy(
() ->
awaitOperationTermination(
@@ -2124,11 +1772,7 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessage(
String.format(
"The scheduler time must not be null during the periodic refresh of the materialized table %s.",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "my_materialized_table")
- .asSerializableString()));
+ objectIdentifier.asSerializableString()));
// refresh the materialized table with invalid schedule time
String invalidTime = "20240103 00:00:00.000";
@@ -2138,9 +1782,9 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
objectIdentifier.asSerializableString(),
true,
invalidTime,
- Collections.emptyMap(),
- Collections.emptyMap(),
- Collections.emptyMap());
+ Map.of(),
+ Map.of(),
+ Map.of());
assertThatThrownBy(
() ->
@@ -2151,27 +1795,36 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
.hasMessage(
String.format(
"Failed to parse a valid partition value for the field 'ds' in materialized table %s using the scheduler time '20240103 00:00:00.000' based on the date format 'yyyy-MM-dd HH:mm:ss'.",
- ObjectIdentifier.of(
- fileSystemCatalogName,
- TEST_DEFAULT_DATABASE,
- "my_materialized_table")
- .asSerializableString()));
+ objectIdentifier.asSerializableString()));
// drop the materialized table
- dropMaterializedTable(
- ObjectIdentifier.of(
- fileSystemCatalogName, TEST_DEFAULT_DATABASE, "my_materialized_table"));
+ dropMaterializedTable(getObjectIdentifier("my_materialized_table"));
}
private void setupSavepointDir(Path temporaryPath) throws Exception {
String savepointDir = "file://" + temporaryPath.toAbsolutePath();
String setupSavepointDDL =
"SET 'execution.checkpointing.savepoint-dir' = '" + savepointDir + "'";
- OperationHandle setupSavepointHandle =
- service.executeStatement(sessionHandle, setupSavepointDDL, -1, new Configuration());
+ OperationHandle setupSavepointHandle = executeStatement(setupSavepointDDL);
awaitOperationTermination(service, sessionHandle, setupSavepointHandle);
}
+ private OperationHandle executeStatement(
+ String statement, long timeoutMs, Configuration config) {
+ return service.executeStatement(sessionHandle, statement, timeoutMs, config);
+ }
+
+ private OperationHandle executeStatement(String statement) {
+ return executeStatement(statement, -1, new Configuration());
+ }
+
+ private ContinuousRefreshHandler getContinuousRefreshHandler(
+ ResolvedCatalogMaterializedTable resolvedTable)
+ throws IOException, ClassNotFoundException {
+ return ContinuousRefreshHandlerSerializer.INSTANCE.deserialize(
+ resolvedTable.getSerializedRefreshHandler(), getClass().getClassLoader());
+ }
+
private List<Column> getAddedColumns(ResolvedSchema newSchema, ResolvedSchema oldSchema) {
return newSchema.getColumns().stream()
.filter(column -> !oldSchema.getColumns().contains(column))
@@ -2215,6 +1868,18 @@ class MaterializedTableStatementITCase extends AbstractMaterializedTableStatemen
: Optional.empty();
}
+ private ObjectIdentifier getObjectIdentifier(String name) {
+ return ObjectIdentifier.of(fileSystemCatalogName, TEST_DEFAULT_DATABASE, name);
+ }
+
+ private JobKey getJobKey(ObjectIdentifier identifier) {
+ return JobKey.jobKey("quartz_job_" + identifier.asSerializableString(), "default_group");
+ }
+
+ private ResolvedCatalogMaterializedTable getTable(ObjectIdentifier identifier) {
+ return (ResolvedCatalogMaterializedTable) service.getTable(sessionHandle, identifier);
+ }
+
private static <M extends JobMessageParameters, R extends RequestBody, P extends ResponseBody>
P sendJobRequest(
RestClusterClient<?> restClusterClient,
diff --git a/flink-table/flink-sql-parser/src/main/codegen/includes/parserImpls.ftl b/flink-table/flink-sql-parser/src/main/codegen/includes/parserImpls.ftl
index d4e0d198d91..b7869b44bcc 100644
--- a/flink-table/flink-sql-parser/src/main/codegen/includes/parserImpls.ftl
+++ b/flink-table/flink-sql-parser/src/main/codegen/includes/parserImpls.ftl
@@ -950,7 +950,9 @@ SqlAlterTable SqlAlterTable() :
|
(
<DISTRIBUTION>
- {return new SqlAlterTableAddDistribution(getPos(), tableIdentifier, SqlDistribution(getPos()));}
+ {
+ return new SqlAlterTableAddDistribution(getPos(), tableIdentifier, SqlDistribution(getPos()));
+ }
|
AlterTableAddOrModify(ctx)
|
@@ -975,7 +977,9 @@ SqlAlterTable SqlAlterTable() :
<MODIFY>
(
<DISTRIBUTION>
- {return new SqlAlterTableModifyDistribution(getPos(), tableIdentifier, SqlDistribution(getPos()));}
+ {
+ return new SqlAlterTableModifyDistribution(getPos(), tableIdentifier, SqlDistribution(getPos()));
+ }
|
AlterTableAddOrModify(ctx)
|
diff --git a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/ddl/SqlAlterMaterializedTableSchema.java b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/ddl/SqlAlterMaterializedTableSchema.java
index a1c51400e7f..20cc31aa6f0 100644
--- a/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/ddl/SqlAlterMaterializedTableSchema.java
+++ b/flink-table/flink-sql-parser/src/main/java/org/apache/flink/sql/parser/ddl/SqlAlterMaterializedTableSchema.java
@@ -86,6 +86,12 @@ public abstract class SqlAlterMaterializedTableSchema extends SqlAlterMaterializ
return constraints;
}
+ public Optional<SqlTableConstraint> getFullConstraint() {
+ List<SqlTableConstraint> primaryKeys =
+ SqlConstraintValidator.getFullConstraints(constraints, getColumns());
+ return primaryKeys.isEmpty() ? Optional.empty() : Optional.of(primaryKeys.get(0));
+ }
+
private SqlNodeList getColumns() {
return new SqlNodeList(
columnList.getList().stream()
@@ -107,7 +113,7 @@ public abstract class SqlAlterMaterializedTableSchema extends SqlAlterMaterializ
/**
* Example: DDL like the below for adding column(s)/constraint/watermark.
*
- * <p>Note: adding or altering physical columns is not supported, only computed or metadata
+ * <p>Note: adding or modifying physical columns is not supported, only computed or metadata
*
* <pre>{@code
* -- add single column
diff --git a/flink-table/flink-table-api-java/src/main/java/org/apache/flink/table/operations/materializedtable/AlterMaterializedTableAsQueryOperation.java b/flink-table/flink-table-api-java/src/main/java/org/apache/flink/table/operations/materializedtable/AlterMaterializedTableAsQueryOperation.java
index 3df90d461f3..07ee773e77e 100644
--- a/flink-table/flink-table-api-java/src/main/java/org/apache/flink/table/operations/materializedtable/AlterMaterializedTableAsQueryOperation.java
+++ b/flink-table/flink-table-api-java/src/main/java/org/apache/flink/table/operations/materializedtable/AlterMaterializedTableAsQueryOperation.java
@@ -22,7 +22,7 @@ import org.apache.flink.annotation.Internal;
import org.apache.flink.table.api.internal.TableResultInternal;
import org.apache.flink.table.catalog.CatalogMaterializedTable;
import org.apache.flink.table.catalog.ObjectIdentifier;
-import org.apache.flink.table.catalog.TableChange.MaterializedTableChange;
+import org.apache.flink.table.catalog.TableChange;
import java.util.List;
@@ -32,7 +32,7 @@ public class AlterMaterializedTableAsQueryOperation extends AlterMaterializedTab
public AlterMaterializedTableAsQueryOperation(
ObjectIdentifier tableIdentifier,
- List<MaterializedTableChange> tableChanges,
+ List<TableChange> tableChanges,
CatalogMaterializedTable catalogMaterializedTable) {
super(tableIdentifier, tableChanges, catalogMaterializedTable);
}
diff --git a/flink-table/flink-table-api-java/src/main/java/org/apache/flink/table/operations/materializedtable/AlterMaterializedTableChangeOperation.java b/flink-table/flink-table-api-java/src/main/java/org/apache/flink/table/operations/materializedtable/AlterMaterializedTableChangeOperation.java
index d71946c7a56..309fea77be8 100644
--- a/flink-table/flink-table-api-java/src/main/java/org/apache/flink/table/operations/materializedtable/AlterMaterializedTableChangeOperation.java
+++ b/flink-table/flink-table-api-java/src/main/java/org/apache/flink/table/operations/materializedtable/AlterMaterializedTableChangeOperation.java
@@ -24,7 +24,6 @@ import org.apache.flink.table.api.internal.TableResultInternal;
import org.apache.flink.table.catalog.CatalogMaterializedTable;
import org.apache.flink.table.catalog.ObjectIdentifier;
import org.apache.flink.table.catalog.TableChange;
-import org.apache.flink.table.catalog.TableChange.MaterializedTableChange;
import org.apache.flink.table.operations.ddl.AlterTableChangeOperation;
import java.util.List;
@@ -36,19 +35,19 @@ import java.util.stream.Collectors;
@Internal
public class AlterMaterializedTableChangeOperation extends AlterMaterializedTableOperation {
- private final List<MaterializedTableChange> tableChanges;
+ private final List<TableChange> tableChanges;
private final CatalogMaterializedTable catalogMaterializedTable;
public AlterMaterializedTableChangeOperation(
ObjectIdentifier tableIdentifier,
- List<MaterializedTableChange> tableChanges,
+ List<TableChange> tableChanges,
CatalogMaterializedTable catalogMaterializedTable) {
super(tableIdentifier);
this.tableChanges = tableChanges;
this.catalogMaterializedTable = catalogMaterializedTable;
}
- public List<MaterializedTableChange> getTableChanges() {
+ public List<TableChange> getTableChanges() {
return tableChanges;
}
@@ -61,9 +60,7 @@ public class AlterMaterializedTableChangeOperation extends AlterMaterializedTabl
ctx.getCatalogManager()
.alterTable(
getCatalogMaterializedTable(),
- getTableChanges().stream()
- .map(TableChange.class::cast)
- .collect(Collectors.toList()),
+ getTableChanges(),
getTableIdentifier(),
false);
return TableResultImpl.TABLE_RESULT_OK;
@@ -79,7 +76,7 @@ public class AlterMaterializedTableChangeOperation extends AlterMaterializedTabl
"ALTER MATERIALIZED TABLE %s\n%s", tableIdentifier.asSummaryString(), changes);
}
- private static String toString(MaterializedTableChange tableChange) {
+ private static String toString(TableChange tableChange) {
if (tableChange instanceof TableChange.ModifyRefreshStatus) {
TableChange.ModifyRefreshStatus refreshStatus =
(TableChange.ModifyRefreshStatus) tableChange;
diff --git a/flink-table/flink-table-api-java/src/test/java/org/apache/flink/table/catalog/CatalogBaseTableResolutionTest.java b/flink-table/flink-table-api-java/src/test/java/org/apache/flink/table/catalog/CatalogBaseTableResolutionTest.java
index 8a0e34e9bc0..05ddc34a23b 100644
--- a/flink-table/flink-table-api-java/src/test/java/org/apache/flink/table/catalog/CatalogBaseTableResolutionTest.java
+++ b/flink-table/flink-table-api-java/src/test/java/org/apache/flink/table/catalog/CatalogBaseTableResolutionTest.java
@@ -21,6 +21,9 @@ package org.apache.flink.table.catalog;
import org.apache.flink.api.common.JobID;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Schema;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.LogicalRefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshStatus;
import org.apache.flink.table.catalog.exceptions.TableNotExistException;
import org.apache.flink.table.expressions.DefaultSqlFactory;
import org.apache.flink.table.expressions.ResolvedExpression;
@@ -253,11 +256,11 @@ class CatalogBaseTableResolutionTest {
assertThat(resolvedCatalogMaterializedTable.getExpandedQuery())
.isEqualTo(DEFAULT_EXPANDED_QUERY);
assertThat(resolvedCatalogMaterializedTable.getLogicalRefreshMode())
- .isEqualTo(CatalogMaterializedTable.LogicalRefreshMode.CONTINUOUS);
+ .isSameAs(LogicalRefreshMode.CONTINUOUS);
assertThat(resolvedCatalogMaterializedTable.getRefreshMode())
- .isEqualTo(CatalogMaterializedTable.RefreshMode.CONTINUOUS);
+ .isSameAs(RefreshMode.CONTINUOUS);
assertThat(resolvedCatalogMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.INITIALIZING);
+ .isSameAs(RefreshStatus.INITIALIZING);
byte[] expectedBytes =
ContinuousRefreshHandlerSerializer.INSTANCE.serialize(CONTINUOUS_REFRESH_HANDLER);
assertThat(resolvedCatalogMaterializedTable.getSerializedRefreshHandler())
@@ -450,9 +453,9 @@ class CatalogBaseTableResolutionTest {
.originalQuery(DEFAULT_ORIGINAL_QUERY)
.expandedQuery(DEFAULT_EXPANDED_QUERY)
.freshness(IntervalFreshness.ofSecond("30"))
- .logicalRefreshMode(CatalogMaterializedTable.LogicalRefreshMode.AUTOMATIC)
- .refreshMode(CatalogMaterializedTable.RefreshMode.CONTINUOUS)
- .refreshStatus(CatalogMaterializedTable.RefreshStatus.INITIALIZING)
+ .logicalRefreshMode(LogicalRefreshMode.AUTOMATIC)
+ .refreshMode(RefreshMode.CONTINUOUS)
+ .refreshStatus(RefreshStatus.INITIALIZING)
.build();
}
diff --git a/flink-table/flink-table-common/src/main/java/org/apache/flink/table/catalog/CatalogPropertiesUtil.java b/flink-table/flink-table-common/src/main/java/org/apache/flink/table/catalog/CatalogPropertiesUtil.java
index 8184797b916..16e9ba8c224 100644
--- a/flink-table/flink-table-common/src/main/java/org/apache/flink/table/catalog/CatalogPropertiesUtil.java
+++ b/flink-table/flink-table-common/src/main/java/org/apache/flink/table/catalog/CatalogPropertiesUtil.java
@@ -22,6 +22,9 @@ import org.apache.flink.annotation.Internal;
import org.apache.flink.table.api.Schema;
import org.apache.flink.table.api.Schema.Builder;
import org.apache.flink.table.api.TableException;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.LogicalRefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshStatus;
import org.apache.flink.table.catalog.Column.ComputedColumn;
import org.apache.flink.table.catalog.Column.MetadataColumn;
import org.apache.flink.table.catalog.exceptions.CatalogException;
@@ -289,13 +292,11 @@ public final class CatalogPropertiesUtil {
IntervalFreshness.TimeUnit.valueOf(properties.get(FRESHNESS_UNIT));
final IntervalFreshness freshness = IntervalFreshness.of(freshnessInterval, timeUnit);
- final CatalogMaterializedTable.LogicalRefreshMode logicalRefreshMode =
- CatalogMaterializedTable.LogicalRefreshMode.valueOf(
- properties.get(LOGICAL_REFRESH_MODE));
- final CatalogMaterializedTable.RefreshMode refreshMode =
- CatalogMaterializedTable.RefreshMode.valueOf(properties.get(REFRESH_MODE));
- final CatalogMaterializedTable.RefreshStatus refreshStatus =
- CatalogMaterializedTable.RefreshStatus.valueOf(properties.get(REFRESH_STATUS));
+ final LogicalRefreshMode logicalRefreshMode =
+ LogicalRefreshMode.valueOf(properties.get(LOGICAL_REFRESH_MODE));
+ final RefreshMode refreshMode = RefreshMode.valueOf(properties.get(REFRESH_MODE));
+ final RefreshStatus refreshStatus =
+ RefreshStatus.valueOf(properties.get(REFRESH_STATUS));
final @Nullable String refreshHandlerDesc = properties.get(REFRESH_HANDLER_DESC);
final @Nullable String refreshHandlerStringBytes =
diff --git a/flink-table/flink-table-common/src/test/java/org/apache/flink/table/catalog/CatalogPropertiesUtilTest.java b/flink-table/flink-table-common/src/test/java/org/apache/flink/table/catalog/CatalogPropertiesUtilTest.java
index 7951662c9fe..6800f8e2ced 100644
--- a/flink-table/flink-table-common/src/test/java/org/apache/flink/table/catalog/CatalogPropertiesUtilTest.java
+++ b/flink-table/flink-table-common/src/test/java/org/apache/flink/table/catalog/CatalogPropertiesUtilTest.java
@@ -20,7 +20,9 @@ package org.apache.flink.table.catalog;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Schema;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.LogicalRefreshMode;
import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshStatus;
import org.apache.flink.table.expressions.DefaultSqlFactory;
import org.junit.jupiter.api.Test;
@@ -161,10 +163,9 @@ class CatalogPropertiesUtilTest {
.originalQuery("SELECT 1, 'two'")
.expandedQuery("SELECT 1, 'two'")
.freshness(IntervalFreshness.ofHour("123"))
- .logicalRefreshMode(
- CatalogMaterializedTable.LogicalRefreshMode.CONTINUOUS)
- .refreshMode(CatalogMaterializedTable.RefreshMode.CONTINUOUS)
- .refreshStatus(CatalogMaterializedTable.RefreshStatus.ACTIVATED)
+ .logicalRefreshMode(LogicalRefreshMode.CONTINUOUS)
+ .refreshMode(RefreshMode.CONTINUOUS)
+ .refreshStatus(RefreshStatus.ACTIVATED)
.refreshHandlerDescription("description")
.build(),
resolvedSchema,
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/AbstractAlterMaterializedTableConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/AbstractAlterMaterializedTableConverter.java
index a1df41d505b..5da49c1cb5c 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/AbstractAlterMaterializedTableConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/AbstractAlterMaterializedTableConverter.java
@@ -20,21 +20,54 @@ package org.apache.flink.table.planner.operations.converters;
import org.apache.flink.sql.parser.ddl.SqlAlterMaterializedTable;
import org.apache.flink.table.api.ValidationException;
+import org.apache.flink.table.catalog.CatalogBaseTable.TableKind;
+import org.apache.flink.table.catalog.CatalogManager;
import org.apache.flink.table.catalog.CatalogMaterializedTable;
+import org.apache.flink.table.catalog.ContextResolvedTable;
import org.apache.flink.table.catalog.ObjectIdentifier;
-import org.apache.flink.table.catalog.ResolvedCatalogBaseTable;
import org.apache.flink.table.catalog.ResolvedCatalogMaterializedTable;
import org.apache.flink.table.catalog.UnresolvedIdentifier;
+import org.apache.flink.table.operations.Operation;
+import org.apache.flink.table.operations.utils.ValidationUtils;
+import java.util.Optional;
import java.util.function.Consumer;
-import java.util.function.Supplier;
-
-import static org.apache.flink.table.catalog.CatalogBaseTable.TableKind.MATERIALIZED_TABLE;
/** Abstract converter for {@link org.apache.flink.sql.parser.ddl.SqlAlterMaterializedTable}. */
public abstract class AbstractAlterMaterializedTableConverter<T extends SqlAlterMaterializedTable>
implements SqlNodeConverter<T> {
+ protected static final String EX_MSG_PREFIX =
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n";
+
+ protected abstract Operation convertToOperation(
+ T sqlAlterTable, ResolvedCatalogMaterializedTable oldTable, ConvertContext context);
+
+ @Override
+ public final Operation convertSqlNode(T sqlAlterMaterializedTable, ConvertContext context) {
+ final CatalogManager catalogManager = context.getCatalogManager();
+ final ObjectIdentifier materializedTableIdentifier =
+ resolveIdentifier(sqlAlterMaterializedTable, context);
+ final Optional<ContextResolvedTable> optionalCatalogMaterializedTable =
+ catalogManager.getTable(materializedTableIdentifier);
+
+ if (optionalCatalogMaterializedTable.isEmpty()
+ || optionalCatalogMaterializedTable.get().isTemporary()) {
+ throw new ValidationException(
+ String.format(
+ "Materialized table %s doesn't exist.", materializedTableIdentifier));
+ }
+ ValidationUtils.validateTableKind(
+ optionalCatalogMaterializedTable.get().getTable(),
+ TableKind.MATERIALIZED_TABLE,
+ "alter materialized table");
+
+ return convertToOperation(
+ sqlAlterMaterializedTable,
+ optionalCatalogMaterializedTable.get().getResolvedTable(),
+ context);
+ }
+
protected ObjectIdentifier resolveIdentifier(
SqlAlterMaterializedTable sqlAlterMaterializedTable, ConvertContext context) {
UnresolvedIdentifier unresolvedIdentifier =
@@ -42,18 +75,6 @@ public abstract class AbstractAlterMaterializedTableConverter<T extends SqlAlter
return context.getCatalogManager().qualifyIdentifier(unresolvedIdentifier);
}
- protected ResolvedCatalogMaterializedTable getResolvedMaterializedTable(
- ConvertContext context, ObjectIdentifier identifier, Supplier<String> errorMessage) {
- ResolvedCatalogBaseTable<?> table =
- context.getCatalogManager().getTableOrError(identifier).getResolvedTable();
-
- if (MATERIALIZED_TABLE != table.getTableKind()) {
- throw new ValidationException(errorMessage.get());
- }
-
- return (ResolvedCatalogMaterializedTable) table;
- }
-
protected CatalogMaterializedTable buildUpdatedMaterializedTable(
ResolvedCatalogMaterializedTable oldTable,
Consumer<CatalogMaterializedTable.Builder> consumer) {
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/AbstractCreateMaterializedTableConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/AbstractCreateMaterializedTableConverter.java
index ece7deab49b..db7c0a4d947 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/AbstractCreateMaterializedTableConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/AbstractCreateMaterializedTableConverter.java
@@ -24,6 +24,7 @@ import org.apache.flink.table.api.ValidationException;
import org.apache.flink.table.catalog.CatalogMaterializedTable;
import org.apache.flink.table.catalog.CatalogMaterializedTable.LogicalRefreshMode;
import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshStatus;
import org.apache.flink.table.catalog.IntervalFreshness;
import org.apache.flink.table.catalog.ObjectIdentifier;
import org.apache.flink.table.catalog.ResolvedCatalogMaterializedTable;
@@ -163,7 +164,7 @@ public abstract class AbstractCreateMaterializedTableConverter<T extends SqlCrea
.freshness(intervalFreshness)
.logicalRefreshMode(logicalRefreshMode)
.refreshMode(refreshMode)
- .refreshStatus(CatalogMaterializedTable.RefreshStatus.INITIALIZING)
+ .refreshStatus(RefreshStatus.INITIALIZING)
.build());
}
@@ -184,7 +185,7 @@ public abstract class AbstractCreateMaterializedTableConverter<T extends SqlCrea
if (schema.getColumn(partitionKey).isEmpty()) {
throw new ValidationException(
String.format(
- "Partition column '%s' not defined in the query schema. Available columns: [%s].",
+ "Partition column '%s' not defined in the query's schema. Available columns: [%s].",
partitionKey,
schema.getColumnNames().stream()
.collect(Collectors.joining("', '", "'", "'"))));
@@ -218,7 +219,7 @@ public abstract class AbstractCreateMaterializedTableConverter<T extends SqlCrea
.contains(LogicalTypeFamily.CHARACTER_STRING)) {
throw new ValidationException(
String.format(
- "Materialized table option '%s' only supports referring to char, varchar and string type partition column. Column %s type is %s.",
+ "Materialized table option '%s' only supports referring to char, varchar and string type partition column. Column `%s` type is %s.",
partitionOption, partitionKey, partitionKeyType.asSummaryString()));
}
}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaAddConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaAddConverter.java
index e46c8a9a53b..4a7a1c3b488 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaAddConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaAddConverter.java
@@ -20,19 +20,18 @@ package org.apache.flink.table.planner.operations.converters;
import org.apache.flink.sql.parser.ddl.position.SqlTableColumnPosition;
import org.apache.flink.table.api.ValidationException;
-import org.apache.flink.table.catalog.ResolvedCatalogTable;
+import org.apache.flink.table.catalog.ResolvedCatalogBaseTable;
import org.apache.flink.table.catalog.TableChange;
-import org.apache.flink.table.catalog.TableDistribution;
import org.apache.flink.table.expressions.SqlCallExpression;
import org.apache.flink.table.planner.operations.converters.SqlNodeConverter.ConvertContext;
import java.util.Collections;
import java.util.stream.Collectors;
-/** Converter for ALTER TABLE ADD ... schema operations. */
+/** Converter for ALTER [MATERIALIZED ]TABLE ADD ... schema operations. */
public class SchemaAddConverter extends SchemaConverter {
- public SchemaAddConverter(ResolvedCatalogTable oldTable, ConvertContext context) {
+ public SchemaAddConverter(ResolvedCatalogBaseTable<?> oldTable, ConvertContext context) {
super(oldTable, context);
}
@@ -41,9 +40,10 @@ public class SchemaAddConverter extends SchemaConverter {
if (primaryKey != null) {
throw new ValidationException(
String.format(
- "%sThe base table has already defined the primary key constraint %s. You might "
+ "%sThe current %s has already defined the primary key constraint %s. You might "
+ "want to drop it before adding a new one.",
- EX_MSG_PREFIX,
+ exMsgPrefix,
+ tableKindStr,
primaryKey.getColumnNames().stream()
.collect(Collectors.joining("`, `", "[`", "`]"))));
}
@@ -52,26 +52,15 @@ public class SchemaAddConverter extends SchemaConverter {
Collections.singletonList(TableChange.add(unwrap(schema.getPrimaryKey()))));
}
- @Override
- protected void checkAndCollectDistributionChange(TableDistribution newDistribution) {
- if (distribution != null) {
- throw new ValidationException(
- String.format(
- "%sThe base table has already defined the distribution `%s`. "
- + "You can modify it or drop it before adding a new one.",
- EX_MSG_PREFIX, distribution));
- }
- changesCollector.add(TableChange.add(newDistribution));
- }
-
@Override
protected void checkAndCollectWatermarkChange() {
if (watermarkSpec != null) {
throw new ValidationException(
String.format(
- "%sThe base table has already defined the watermark strategy `%s` AS %s. You might "
+ "%sThe current %s has already defined the watermark strategy `%s` AS %s. You might "
+ "want to drop it before adding a new one.",
- EX_MSG_PREFIX,
+ exMsgPrefix,
+ tableKindStr,
watermarkSpec.getColumnName(),
((SqlCallExpression) watermarkSpec.getWatermarkExpression())
.getSqlExpression()));
@@ -88,8 +77,8 @@ public class SchemaAddConverter extends SchemaConverter {
if (sortedColumnNames.contains(columnName)) {
throw new ValidationException(
String.format(
- "%sTry to add a column `%s` which already exists in the table.",
- EX_MSG_PREFIX, columnName));
+ "%sColumn `%s` already exists in the %s.",
+ exMsgPrefix, columnName, tableKindStr));
}
if (columnPosition.isFirstColumn()) {
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaConverter.java
index d0108006bd9..c1c2becdbe8 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaConverter.java
@@ -18,7 +18,6 @@
package org.apache.flink.table.planner.operations.converters;
-import org.apache.flink.sql.parser.ddl.SqlDistribution;
import org.apache.flink.sql.parser.ddl.SqlTableColumn;
import org.apache.flink.sql.parser.ddl.SqlWatermark;
import org.apache.flink.sql.parser.ddl.constraint.SqlTableConstraint;
@@ -26,10 +25,10 @@ import org.apache.flink.sql.parser.ddl.position.SqlTableColumnPosition;
import org.apache.flink.table.api.Schema;
import org.apache.flink.table.api.TableException;
import org.apache.flink.table.api.ValidationException;
-import org.apache.flink.table.catalog.ResolvedCatalogTable;
+import org.apache.flink.table.catalog.CatalogBaseTable.TableKind;
+import org.apache.flink.table.catalog.ResolvedCatalogBaseTable;
import org.apache.flink.table.catalog.ResolvedSchema;
import org.apache.flink.table.catalog.TableChange;
-import org.apache.flink.table.catalog.TableDistribution;
import org.apache.flink.table.expressions.SqlCallExpression;
import org.apache.flink.table.planner.operations.converters.SqlNodeConverter.ConvertContext;
import org.apache.flink.table.planner.utils.OperationConverterUtils;
@@ -49,6 +48,7 @@ import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
+import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
@@ -60,12 +60,13 @@ import static org.apache.flink.table.types.utils.TypeConversions.fromLogicalToDa
/** Base class for schema conversion operations. */
public abstract class SchemaConverter {
- protected static final String EX_MSG_PREFIX = "Failed to execute ALTER TABLE statement.\n";
+ private static final String ERROR_TEMPLATE = "Failed to execute ALTER %s statement.\n";
+ protected final String exMsgPrefix;
+ protected final String tableKindStr;
protected List<String> sortedColumnNames = new ArrayList<>();
protected Set<String> alterColNames = new HashSet<>();
protected Map<String, Schema.UnresolvedColumn> columns = new HashMap<>();
protected @Nullable Schema.UnresolvedWatermarkSpec watermarkSpec = null;
- protected @Nullable TableDistribution distribution = null;
protected @Nullable Schema.UnresolvedPrimaryKey primaryKey = null;
protected Function<SqlNode, String> escapeExpressions;
@@ -74,8 +75,11 @@ public abstract class SchemaConverter {
protected List<TableChange> changesCollector;
protected List<Function<ResolvedSchema, List<TableChange>>> changeBuilders = new ArrayList<>();
- SchemaConverter(ResolvedCatalogTable oldTable, ConvertContext context) {
+ SchemaConverter(ResolvedCatalogBaseTable<?> oldTable, ConvertContext context) {
this.changesCollector = new ArrayList<>();
+ final TableKind tableKind = oldTable.getTableKind();
+ this.tableKindStr = tableKind.toString().toLowerCase(Locale.ROOT).replace('_', ' ');
+ this.exMsgPrefix = String.format(ERROR_TEMPLATE, tableKindStr.toUpperCase(Locale.ROOT));
this.context = context;
this.escapeExpressions =
sqlNode ->
@@ -85,7 +89,6 @@ public abstract class SchemaConverter {
populateColumnsFromSourceTable(oldSchema);
populatePrimaryKeyFromSourceTable(oldSchema);
populateWatermarkFromSourceTable(oldSchema);
- populateDistributionFromSourceTable(oldTable);
}
public List<TableChange> getChangesCollector() {
@@ -109,10 +112,6 @@ public abstract class SchemaConverter {
}
}
- private void populateDistributionFromSourceTable(ResolvedCatalogTable oldTable) {
- oldTable.getDistribution().ifPresent(distribution -> this.distribution = distribution);
- }
-
private void populateWatermarkFromSourceTable(Schema oldSchema) {
for (Schema.UnresolvedWatermarkSpec sourceWatermarkSpec : oldSchema.getWatermarkSpecs()) {
watermarkSpec = sourceWatermarkSpec;
@@ -175,7 +174,7 @@ public abstract class SchemaConverter {
throw new ValidationException(
String.format(
"%sWatermark strategy on nested column is not supported yet.",
- EX_MSG_PREFIX));
+ exMsgPrefix));
}
watermarkSpec =
new Schema.UnresolvedWatermarkSpec(
@@ -185,14 +184,6 @@ public abstract class SchemaConverter {
alterWatermarkSpec.getWatermarkStrategy())));
}
- public void updateDistribution(SqlDistribution distribution) {
- TableDistribution tableDistribution =
- OperationConverterUtils.getDistributionFromSqlDistribution(distribution);
- checkAndCollectDistributionChange(tableDistribution);
- this.distribution =
- OperationConverterUtils.getDistributionFromSqlDistribution(distribution);
- }
-
private Schema.UnresolvedPhysicalColumn convertPhysicalColumn(
SqlTableColumn.SqlRegularColumn physicalColumn) {
DataType dataType = getDataType(physicalColumn.getType());
@@ -240,7 +231,7 @@ public abstract class SchemaConverter {
if (!alterColNames.add(columnName)) {
throw new ValidationException(
String.format(
- "%sEncounter duplicate column `%s`.", EX_MSG_PREFIX, columnName));
+ "%sEncounter duplicate column `%s`.", exMsgPrefix, columnName));
}
updatePositionAndCollectColumnChange(columnPosition, columnName);
}
@@ -249,18 +240,17 @@ public abstract class SchemaConverter {
protected String getReferencedColumn(SqlTableColumnPosition columnPosition) {
SqlIdentifier referencedIdent = columnPosition.getAfterReferencedColumn();
Preconditions.checkNotNull(
- referencedIdent,
- String.format("%sCould not refer to a null column", EX_MSG_PREFIX));
+ referencedIdent, String.format("%sCould not refer to a null column", exMsgPrefix));
if (!referencedIdent.isSimple()) {
throw new UnsupportedOperationException(
- String.format("%sAlter nested row type is not supported yet.", EX_MSG_PREFIX));
+ String.format("%sAlter nested row type is not supported yet.", exMsgPrefix));
}
String referencedName = referencedIdent.getSimple();
if (!sortedColumnNames.contains(referencedName)) {
throw new ValidationException(
String.format(
"%sReferenced column `%s` by 'AFTER' does not exist in the table.",
- EX_MSG_PREFIX, referencedName));
+ exMsgPrefix, referencedName));
}
return referencedName;
}
@@ -298,7 +288,7 @@ public abstract class SchemaConverter {
.collect(Collectors.toList()));
return updatedSchema;
} catch (Exception e) {
- throw new ValidationException(String.format("%s%s", EX_MSG_PREFIX, e.getMessage()), e);
+ throw new ValidationException(String.format("%s%s", exMsgPrefix, e.getMessage()), e);
}
}
@@ -307,16 +297,14 @@ public abstract class SchemaConverter {
protected abstract void checkAndCollectPrimaryKeyChange();
- protected abstract void checkAndCollectDistributionChange(TableDistribution distribution);
-
protected abstract void checkAndCollectWatermarkChange();
- protected static String getColumnName(SqlIdentifier identifier) {
+ protected String getColumnName(SqlIdentifier identifier) {
if (!identifier.isSimple()) {
throw new UnsupportedOperationException(
String.format(
"%sAlter nested row type %s is not supported yet.",
- EX_MSG_PREFIX, identifier));
+ exMsgPrefix, identifier));
}
return identifier.getSimple();
}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaModifyConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaModifyConverter.java
index eaa169b5aa2..93d4b5ea9aa 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaModifyConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SchemaModifyConverter.java
@@ -22,9 +22,8 @@ import org.apache.flink.sql.parser.ddl.SqlTableColumn;
import org.apache.flink.sql.parser.ddl.position.SqlTableColumnPosition;
import org.apache.flink.table.api.ValidationException;
import org.apache.flink.table.catalog.Column;
-import org.apache.flink.table.catalog.ResolvedCatalogTable;
+import org.apache.flink.table.catalog.ResolvedCatalogBaseTable;
import org.apache.flink.table.catalog.TableChange;
-import org.apache.flink.table.catalog.TableDistribution;
import org.apache.flink.table.planner.operations.converters.SqlNodeConverter.ConvertContext;
import javax.annotation.Nullable;
@@ -34,14 +33,14 @@ import java.util.Collections;
import java.util.List;
import java.util.Objects;
-/** Converter for ALTER TABLE MODIFY ... schema operations. */
+/** Converter for ALTER [MATERIALIZED ]TABLE MODIFY ... schema operations. */
public class SchemaModifyConverter extends SchemaConverter {
- private final ResolvedCatalogTable oldTable;
+ private final ResolvedCatalogBaseTable<?> oldBaseTable;
- public SchemaModifyConverter(ResolvedCatalogTable oldTable, ConvertContext context) {
- super(oldTable, context);
- this.oldTable = oldTable;
+ public SchemaModifyConverter(ResolvedCatalogBaseTable<?> oldBaseTable, ConvertContext context) {
+ super(oldBaseTable, context);
+ this.oldBaseTable = oldBaseTable;
}
@Override
@@ -50,11 +49,10 @@ public class SchemaModifyConverter extends SchemaConverter {
if (!sortedColumnNames.contains(columnName)) {
throw new ValidationException(
String.format(
- "%sTry to modify a column `%s` which does not exist in the table.",
- EX_MSG_PREFIX, columnName));
+ "%sColumn `%s` does not exist in the table.", exMsgPrefix, columnName));
}
- Column oldColumn = unwrap(oldTable.getResolvedSchema().getColumn(columnName));
+ Column oldColumn = unwrap(oldBaseTable.getResolvedSchema().getColumn(columnName));
if (columnPosition.isFirstColumn()) {
sortedColumnNames.remove(columnName);
sortedColumnNames.add(0, columnName);
@@ -89,9 +87,9 @@ public class SchemaModifyConverter extends SchemaConverter {
if (primaryKey == null) {
throw new ValidationException(
String.format(
- "%sThe base table does not define any primary key constraint. You might "
+ "%sThe current %s does not define any primary key constraint. You might "
+ "want to add a new one.",
- EX_MSG_PREFIX));
+ exMsgPrefix, tableKindStr));
}
changeBuilders.add(
schema ->
@@ -99,26 +97,14 @@ public class SchemaModifyConverter extends SchemaConverter {
TableChange.modify(unwrap(schema.getPrimaryKey()))));
}
- @Override
- protected void checkAndCollectDistributionChange(TableDistribution newDistribution) {
- if (distribution == null) {
- throw new ValidationException(
- String.format(
- "%sThe base table does not define any distribution. You might "
- + "want to add a new one.",
- EX_MSG_PREFIX));
- }
- changesCollector.add(TableChange.modify(newDistribution));
- }
-
@Override
protected void checkAndCollectWatermarkChange() {
if (watermarkSpec == null) {
throw new ValidationException(
String.format(
- "%sThe base table does not define any watermark. You might "
+ "%sThe current %s does not define any watermark. You might "
+ "want to add a new one.",
- EX_MSG_PREFIX));
+ exMsgPrefix, tableKindStr));
}
changeBuilders.add(
schema ->
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableAddDistributionConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableAddDistributionConverter.java
index 78c86edb089..51ba7f93445 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableAddDistributionConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableAddDistributionConverter.java
@@ -18,10 +18,10 @@
package org.apache.flink.table.planner.operations.converters;
+import org.apache.flink.sql.parser.ddl.SqlAlterMaterializedTableDistribution;
import org.apache.flink.sql.parser.ddl.SqlAlterMaterializedTableDistribution.SqlAlterMaterializedTableAddDistribution;
import org.apache.flink.table.api.ValidationException;
import org.apache.flink.table.catalog.CatalogMaterializedTable;
-import org.apache.flink.table.catalog.ObjectIdentifier;
import org.apache.flink.table.catalog.ResolvedCatalogMaterializedTable;
import org.apache.flink.table.catalog.TableChange;
import org.apache.flink.table.catalog.TableDistribution;
@@ -30,38 +30,40 @@ import org.apache.flink.table.operations.materializedtable.AlterMaterializedTabl
import org.apache.flink.table.planner.utils.OperationConverterUtils;
import java.util.List;
+import java.util.Optional;
/** A converter for {@link SqlAlterMaterializedTableAddDistribution}. */
public class SqlAlterMaterializedTableAddDistributionConverter
extends AbstractAlterMaterializedTableConverter<SqlAlterMaterializedTableAddDistribution> {
@Override
- public Operation convertSqlNode(
- SqlAlterMaterializedTableAddDistribution node, ConvertContext context) {
- ObjectIdentifier identifier = resolveIdentifier(node, context);
-
- ResolvedCatalogMaterializedTable oldTable =
- getResolvedMaterializedTable(
- context,
- identifier,
- () -> "Operation is supported only for materialized tables");
+ protected Operation convertToOperation(
+ SqlAlterMaterializedTableAddDistribution sqlAddDistribution,
+ ResolvedCatalogMaterializedTable oldTable,
+ ConvertContext context) {
+ TableDistribution distribution = getTableDistribution(sqlAddDistribution, oldTable);
+ // Build new materialized table and apply changes
+ CatalogMaterializedTable updatedTable =
+ buildUpdatedMaterializedTable(
+ oldTable, builder -> builder.distribution(distribution));
+ return new AlterMaterializedTableChangeOperation(
+ resolveIdentifier(sqlAddDistribution, context),
+ List.of(TableChange.add(distribution)),
+ updatedTable);
+ }
- if (oldTable.getDistribution().isPresent()) {
+ private TableDistribution getTableDistribution(
+ SqlAlterMaterializedTableDistribution sqlAlterTableDistribution,
+ ResolvedCatalogMaterializedTable oldTable) {
+ Optional<TableDistribution> oldDistribution = oldTable.getDistribution();
+ if (oldDistribution.isPresent()) {
throw new ValidationException(
String.format(
- "Materialized table %s has already defined the distribution `%s`. "
+ "%sThe current materialized table has already defined the distribution `%s`. "
+ "You can modify it or drop it before adding a new one.",
- identifier, oldTable.getDistribution().get().toString().strip()));
+ EX_MSG_PREFIX, oldDistribution.get()));
}
- TableDistribution tableDistribution =
- OperationConverterUtils.getDistributionFromSqlDistribution(
- node.getDistribution().get());
- // Build new materialized table and apply changes
- CatalogMaterializedTable updatedTable =
- buildUpdatedMaterializedTable(
- oldTable, builder -> builder.distribution(tableDistribution));
-
- return new AlterMaterializedTableChangeOperation(
- identifier, List.of(TableChange.add(tableDistribution)), updatedTable);
+ return OperationConverterUtils.getDistributionFromSqlDistribution(
+ sqlAlterTableDistribution.getDistribution().get());
}
}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableAsQueryConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableAsQueryConverter.java
index 7deda62b12e..b9cba453350 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableAsQueryConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableAsQueryConverter.java
@@ -26,7 +26,6 @@ import org.apache.flink.table.catalog.ObjectIdentifier;
import org.apache.flink.table.catalog.ResolvedCatalogMaterializedTable;
import org.apache.flink.table.catalog.ResolvedSchema;
import org.apache.flink.table.catalog.TableChange;
-import org.apache.flink.table.catalog.TableChange.MaterializedTableChange;
import org.apache.flink.table.operations.Operation;
import org.apache.flink.table.operations.materializedtable.AlterMaterializedTableAsQueryOperation;
import org.apache.flink.table.planner.operations.PlannerQueryOperation;
@@ -42,27 +41,20 @@ public class SqlAlterMaterializedTableAsQueryConverter
extends AbstractAlterMaterializedTableConverter<SqlAlterMaterializedTableAsQuery> {
@Override
- public Operation convertSqlNode(
- SqlAlterMaterializedTableAsQuery sqlAlterMaterializedTableAsQuery,
+ protected Operation convertToOperation(
+ SqlAlterMaterializedTableAsQuery sqlAlterTableAsQuery,
+ ResolvedCatalogMaterializedTable oldTable,
ConvertContext context) {
- ObjectIdentifier identifier = resolveIdentifier(sqlAlterMaterializedTableAsQuery, context);
+ ObjectIdentifier identifier = resolveIdentifier(sqlAlterTableAsQuery, context);
// Validate and extract schema from query
- String originalQuery =
- context.toQuotedSqlString(sqlAlterMaterializedTableAsQuery.getAsQuery());
+ String originalQuery = context.toQuotedSqlString(sqlAlterTableAsQuery.getAsQuery());
SqlNode validatedQuery =
- context.getSqlValidator().validate(sqlAlterMaterializedTableAsQuery.getAsQuery());
+ context.getSqlValidator().validate(sqlAlterTableAsQuery.getAsQuery());
String definitionQuery = context.toQuotedSqlString(validatedQuery);
PlannerQueryOperation queryOperation =
new PlannerQueryOperation(
context.toRelRoot(validatedQuery).project(), () -> definitionQuery);
-
- ResolvedCatalogMaterializedTable oldTable =
- getResolvedMaterializedTable(
- context,
- identifier,
- () -> "Only materialized tables support modifying the definition query.");
-
ResolvedSchema oldSchema = oldTable.getResolvedSchema();
List<Column> addedColumns =
MaterializedTableUtils.validateAndExtractNewColumns(
@@ -72,7 +64,7 @@ public class SqlAlterMaterializedTableAsQueryConverter
CatalogMaterializedTable updatedTable =
buildUpdatedMaterializedTable(
oldTable, addedColumns, originalQuery, definitionQuery);
- List<MaterializedTableChange> tableChanges = new ArrayList<>();
+ List<TableChange> tableChanges = new ArrayList<>();
addedColumns.forEach(column -> tableChanges.add(TableChange.add(column)));
tableChanges.add(TableChange.modifyDefinitionQuery(definitionQuery));
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableDropDistributionConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableDropDistributionConverter.java
index 07c8d0951c7..56ace44747d 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableDropDistributionConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableDropDistributionConverter.java
@@ -33,16 +33,11 @@ import java.util.List;
public class SqlAlterMaterializedTableDropDistributionConverter
extends AbstractAlterMaterializedTableConverter<SqlAlterMaterializedTableDropDistribution> {
@Override
- public Operation convertSqlNode(
- SqlAlterMaterializedTableDropDistribution node, ConvertContext context) {
- ObjectIdentifier identifier = resolveIdentifier(node, context);
-
- ResolvedCatalogMaterializedTable oldTable =
- getResolvedMaterializedTable(
- context,
- identifier,
- () -> "Operation is supported only for materialized tables");
-
+ protected Operation convertToOperation(
+ SqlAlterMaterializedTableDropDistribution sqlDropDistribution,
+ ResolvedCatalogMaterializedTable oldTable,
+ ConvertContext context) {
+ ObjectIdentifier identifier = resolveIdentifier(sqlDropDistribution, context);
if (oldTable.getDistribution().isEmpty()) {
throw new ValidationException(
String.format(
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableModifyDistributionConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableModifyDistributionConverter.java
index a97d6db6d76..f857a82699b 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableModifyDistributionConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableModifyDistributionConverter.java
@@ -35,17 +35,13 @@ import java.util.List;
public class SqlAlterMaterializedTableModifyDistributionConverter
extends AbstractAlterMaterializedTableConverter<
SqlAlterMaterializedTableModifyDistribution> {
- @Override
- public Operation convertSqlNode(
- SqlAlterMaterializedTableModifyDistribution node, ConvertContext context) {
- ObjectIdentifier identifier = resolveIdentifier(node, context);
-
- ResolvedCatalogMaterializedTable oldTable =
- getResolvedMaterializedTable(
- context,
- identifier,
- () -> "Operation is supported only for materialized tables");
+ @Override
+ protected Operation convertToOperation(
+ SqlAlterMaterializedTableModifyDistribution sqlModifyDistribution,
+ ResolvedCatalogMaterializedTable oldTable,
+ ConvertContext context) {
+ ObjectIdentifier identifier = resolveIdentifier(sqlModifyDistribution, context);
if (oldTable.getDistribution().isEmpty()) {
throw new ValidationException(
String.format(
@@ -55,7 +51,7 @@ public class SqlAlterMaterializedTableModifyDistributionConverter
TableDistribution tableDistribution =
OperationConverterUtils.getDistributionFromSqlDistribution(
- node.getDistribution().get());
+ sqlModifyDistribution.getDistribution().get());
// Build new materialized table and apply changes
CatalogMaterializedTable updatedTable =
buildUpdatedMaterializedTable(
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableSchemaConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableSchemaConverter.java
new file mode 100644
index 00000000000..aef2976b517
--- /dev/null
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlAlterMaterializedTableSchemaConverter.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.flink.table.planner.operations.converters;
+
+import org.apache.flink.sql.parser.ddl.SqlAlterMaterializedTableSchema;
+import org.apache.flink.sql.parser.ddl.SqlAlterMaterializedTableSchema.SqlAlterMaterializedTableAddSchema;
+import org.apache.flink.table.api.Schema;
+import org.apache.flink.table.catalog.CatalogMaterializedTable;
+import org.apache.flink.table.catalog.ResolvedCatalogMaterializedTable;
+import org.apache.flink.table.operations.Operation;
+import org.apache.flink.table.operations.materializedtable.AlterMaterializedTableChangeOperation;
+import org.apache.flink.table.planner.utils.MaterializedTableUtils;
+
+/**
+ * Abstract class for converting {@link SqlAlterMaterializedTableSchema} and its children for alter
+ * schema materialized table operations.
+ */
+public abstract class SqlAlterMaterializedTableSchemaConverter<
+ T extends SqlAlterMaterializedTableSchema>
+ extends AbstractAlterMaterializedTableConverter<T> {
+ @Override
+ protected Operation convertToOperation(
+ T alterTableSchema, ResolvedCatalogMaterializedTable oldTable, ConvertContext context) {
+ MaterializedTableUtils.validatePersistedColumnsUsedByQuery(
+ oldTable, alterTableSchema, context);
+
+ SchemaConverter converter = createSchemaConverter(oldTable, context);
+ converter.updateColumn(alterTableSchema.getColumnPositions().getList());
+ alterTableSchema.getWatermark().ifPresent(converter::updateWatermark);
+ alterTableSchema.getFullConstraint().ifPresent(converter::updatePrimaryKey);
+ Schema schema = converter.convert();
+
+ CatalogMaterializedTable mtWithUpdatedSchemaAndQuery =
+ buildUpdatedMaterializedTable(oldTable, builder -> builder.schema(schema));
+
+ return new AlterMaterializedTableChangeOperation(
+ resolveIdentifier(alterTableSchema, context),
+ converter.changesCollector,
+ mtWithUpdatedSchemaAndQuery);
+ }
+
+ protected abstract SchemaConverter createSchemaConverter(
+ ResolvedCatalogMaterializedTable oldTable, ConvertContext context);
+
+ /** A converter for {@link SqlAlterMaterializedTableAddSchema}. */
+ public static class SqlAlterMaterializedTableAddSchemaConverter
+ extends SqlAlterMaterializedTableSchemaConverter<SqlAlterMaterializedTableAddSchema> {
+ @Override
+ protected SchemaConverter createSchemaConverter(
+ ResolvedCatalogMaterializedTable oldTable, ConvertContext context) {
+ return new SchemaAddConverter(oldTable, context);
+ }
+ }
+}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlCreateOrAlterMaterializedTableConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlCreateOrAlterMaterializedTableConverter.java
index 2e20f895d3c..f43d3f07373 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlCreateOrAlterMaterializedTableConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlCreateOrAlterMaterializedTableConverter.java
@@ -34,7 +34,6 @@ import org.apache.flink.table.catalog.ResolvedCatalogBaseTable;
import org.apache.flink.table.catalog.ResolvedCatalogMaterializedTable;
import org.apache.flink.table.catalog.ResolvedSchema;
import org.apache.flink.table.catalog.TableChange;
-import org.apache.flink.table.catalog.TableChange.MaterializedTableChange;
import org.apache.flink.table.catalog.TableDistribution;
import org.apache.flink.table.operations.Operation;
import org.apache.flink.table.operations.materializedtable.AlterMaterializedTableAsQueryOperation;
@@ -101,38 +100,36 @@ public class SqlCreateOrAlterMaterializedTableConverter
}
private Operation handleAlter(
- final SqlCreateOrAlterMaterializedTable sqlCreateOrAlterMaterializedTable,
- final ResolvedCatalogMaterializedTable oldMaterializedTable,
+ final SqlCreateOrAlterMaterializedTable sqlCreateOrAlterTable,
+ final ResolvedCatalogMaterializedTable oldTable,
final ConvertContext context,
final ObjectIdentifier identifier) {
final CatalogMaterializedTable newTable =
buildNewCatalogMaterializedTableFromOldTable(
- oldMaterializedTable, sqlCreateOrAlterMaterializedTable, context);
+ oldTable, sqlCreateOrAlterTable, context);
- List<MaterializedTableChange> tableChanges =
- buildTableChanges(sqlCreateOrAlterMaterializedTable, oldMaterializedTable, context);
+ List<TableChange> tableChanges =
+ buildTableChanges(sqlCreateOrAlterTable, oldTable, context);
return new AlterMaterializedTableAsQueryOperation(identifier, tableChanges, newTable);
}
private Operation handleCreate(
- final SqlCreateOrAlterMaterializedTable sqlCreateOrAlterMaterializedTable,
+ final SqlCreateOrAlterMaterializedTable sqlCreateOrAlterTable,
final ConvertContext context,
final ObjectIdentifier identifier) {
- final ResolvedCatalogMaterializedTable resolvedCatalogMaterializedTable =
- this.getResolvedCatalogMaterializedTable(
- sqlCreateOrAlterMaterializedTable, context);
+ final ResolvedCatalogMaterializedTable resolvedTable =
+ this.getResolvedCatalogMaterializedTable(sqlCreateOrAlterTable, context);
- return new CreateMaterializedTableOperation(identifier, resolvedCatalogMaterializedTable);
+ return new CreateMaterializedTableOperation(identifier, resolvedTable);
}
- private List<MaterializedTableChange> buildTableChanges(
- final SqlCreateOrAlterMaterializedTable sqlCreateOrAlterMaterializedTable,
+ private List<TableChange> buildTableChanges(
+ final SqlCreateOrAlterMaterializedTable sqlCreateOrAlterTable,
final ResolvedCatalogMaterializedTable oldTable,
final ConvertContext context) {
- List<MaterializedTableChange> changes = new ArrayList<>();
- final MergeContext mergeContext =
- this.getMergeContext(sqlCreateOrAlterMaterializedTable, context);
+ List<TableChange> changes = new ArrayList<>();
+ final MergeContext mergeContext = this.getMergeContext(sqlCreateOrAlterTable, context);
final ResolvedSchema oldSchema = oldTable.getResolvedSchema();
final List<Column> newColumns =
@@ -146,26 +143,24 @@ public class SqlCreateOrAlterMaterializedTableConverter
}
private CatalogMaterializedTable buildNewCatalogMaterializedTableFromOldTable(
- final ResolvedCatalogMaterializedTable oldMaterializedTable,
- final SqlCreateOrAlterMaterializedTable sqlCreateOrAlterMaterializedTable,
+ final ResolvedCatalogMaterializedTable oldTable,
+ final SqlCreateOrAlterMaterializedTable sqlCreateOrAlterTable,
final ConvertContext context) {
final Schema.Builder schemaBuilder =
- Schema.newBuilder().fromResolvedSchema(oldMaterializedTable.getResolvedSchema());
+ Schema.newBuilder().fromResolvedSchema(oldTable.getResolvedSchema());
// Add new columns if this is an alter operation
- final ResolvedSchema oldSchema = oldMaterializedTable.getResolvedSchema();
- final MergeContext mergeContext =
- this.getMergeContext(sqlCreateOrAlterMaterializedTable, context);
+ final ResolvedSchema oldSchema = oldTable.getResolvedSchema();
+ final MergeContext mergeContext = this.getMergeContext(sqlCreateOrAlterTable, context);
final List<Column> newColumns =
MaterializedTableUtils.validateAndExtractNewColumns(
oldSchema, mergeContext.getMergedQuerySchema());
newColumns.forEach(col -> schemaBuilder.column(col.getName(), col.getDataType()));
- final String comment = sqlCreateOrAlterMaterializedTable.getComment();
- final IntervalFreshness freshness =
- this.getDerivedFreshness(sqlCreateOrAlterMaterializedTable);
+ final String comment = sqlCreateOrAlterTable.getComment();
+ final IntervalFreshness freshness = this.getDerivedFreshness(sqlCreateOrAlterTable);
final LogicalRefreshMode logicalRefreshMode =
- this.getDerivedLogicalRefreshMode(sqlCreateOrAlterMaterializedTable);
+ this.getDerivedLogicalRefreshMode(sqlCreateOrAlterTable);
final RefreshMode refreshMode = this.getDerivedRefreshMode(logicalRefreshMode);
CatalogMaterializedTable.Builder builder =
@@ -183,10 +178,8 @@ public class SqlCreateOrAlterMaterializedTableConverter
.refreshStatus(RefreshStatus.INITIALIZING);
// Preserve refresh handler from old materialized table
- oldMaterializedTable
- .getRefreshHandlerDescription()
- .ifPresent(builder::refreshHandlerDescription);
- builder.serializedRefreshHandler(oldMaterializedTable.getSerializedRefreshHandler());
+ oldTable.getRefreshHandlerDescription().ifPresent(builder::refreshHandlerDescription);
+ builder.serializedRefreshHandler(oldTable.getSerializedRefreshHandler());
return builder.build();
}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlNodeConverters.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlNodeConverters.java
index 110d9267ad3..c617dced631 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlNodeConverters.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlNodeConverters.java
@@ -21,6 +21,7 @@ package org.apache.flink.table.planner.operations.converters;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.java.typeutils.TypeExtractor;
import org.apache.flink.table.operations.Operation;
+import org.apache.flink.table.planner.operations.converters.SqlAlterMaterializedTableSchemaConverter.SqlAlterMaterializedTableAddSchemaConverter;
import org.apache.flink.table.planner.operations.converters.SqlNodeConverter.ConvertContext;
import org.apache.flink.table.planner.operations.converters.table.SqlAlterTableAddDistributionConverter;
import org.apache.flink.table.planner.operations.converters.table.SqlAlterTableAddPartitionConverter;
@@ -118,6 +119,7 @@ public class SqlNodeConverters {
private static void registerMaterializedTableConverters() {
register(new SqlAlterMaterializedTableAddDistributionConverter());
+ register(new SqlAlterMaterializedTableAddSchemaConverter());
register(new SqlAlterMaterializedTableAsQueryConverter());
register(new SqlAlterMaterializedTableDropDistributionConverter());
register(new SqlAlterMaterializedTableModifyDistributionConverter());
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/AbstractAlterTableConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/AbstractAlterTableConverter.java
index 55577c19d42..644fd84b4f9 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/AbstractAlterTableConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/AbstractAlterTableConverter.java
@@ -51,9 +51,9 @@ public abstract class AbstractAlterTableConverter<T extends SqlAlterTable>
@Override
public final Operation convertSqlNode(T sqlAlterTable, ConvertContext context) {
- CatalogManager catalogManager = context.getCatalogManager();
+ final CatalogManager catalogManager = context.getCatalogManager();
final ObjectIdentifier tableIdentifier = resolveIdentifier(sqlAlterTable, context);
- Optional<ContextResolvedTable> optionalCatalogTable =
+ final Optional<ContextResolvedTable> optionalCatalogTable =
catalogManager.getTable(tableIdentifier);
if (optionalCatalogTable.isEmpty() || optionalCatalogTable.get().isTemporary()) {
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/MergeTableAsUtil.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/MergeTableAsUtil.java
index 1af8044cc25..adc09aed394 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/MergeTableAsUtil.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/MergeTableAsUtil.java
@@ -24,6 +24,7 @@ import org.apache.flink.sql.parser.ddl.SqlTableColumn.SqlMetadataColumn;
import org.apache.flink.sql.parser.ddl.SqlTableColumn.SqlRegularColumn;
import org.apache.flink.sql.parser.ddl.SqlWatermark;
import org.apache.flink.sql.parser.ddl.constraint.SqlTableConstraint;
+import org.apache.flink.sql.parser.ddl.position.SqlTableColumnPosition;
import org.apache.flink.table.api.Schema;
import org.apache.flink.table.api.Schema.UnresolvedColumn;
import org.apache.flink.table.api.Schema.UnresolvedMetadataColumn;
@@ -32,7 +33,7 @@ import org.apache.flink.table.api.TableException;
import org.apache.flink.table.api.ValidationException;
import org.apache.flink.table.catalog.CatalogManager;
import org.apache.flink.table.catalog.DataTypeFactory;
-import org.apache.flink.table.catalog.ResolvedCatalogTable;
+import org.apache.flink.table.catalog.ResolvedCatalogBaseTable;
import org.apache.flink.table.catalog.ResolvedSchema;
import org.apache.flink.table.planner.calcite.FlinkCalciteSqlValidator;
import org.apache.flink.table.planner.calcite.FlinkPlannerImpl;
@@ -97,7 +98,7 @@ public class MergeTableAsUtil {
FlinkPlannerImpl flinkPlanner,
PlannerQueryOperation origQueryOperation,
SqlNode origQueryNode,
- ResolvedCatalogTable sinkTable) {
+ ResolvedCatalogBaseTable<?> sinkTable) {
FlinkCalciteSqlValidator sqlValidator = flinkPlanner.getOrCreateSqlValidator();
SqlRewriterUtils rewriterUtils = new SqlRewriterUtils(sqlValidator);
FlinkTypeFactory typeFactory = (FlinkTypeFactory) sqlValidator.getTypeFactory();
@@ -275,7 +276,8 @@ public class MergeTableAsUtil {
int sinkColumnPos = -1;
for (SqlNode sinkColumn : sinkCols) {
- String name = ((SqlTableColumn) sinkColumn).getName().getSimple();
+ final SqlTableColumn column = toSqlTableColumn(sinkColumn);
+ String name = column.getName().getSimple();
sinkColumnPos++;
if (sinkSchemaCols.containsKey(name)) {
@@ -284,36 +286,29 @@ public class MergeTableAsUtil {
"A column named '%s' already exists in the schema. ", name));
}
- UnresolvedColumn unresolvedSinkColumn;
-
- if (sinkColumn instanceof SqlRegularColumn) {
- unresolvedSinkColumn =
- toUnresolvedPhysicalColumn((SqlRegularColumn) sinkColumn);
-
- regularAndMetadataFieldNamesToTypes.put(
- name, toRelDataType(((SqlRegularColumn) sinkColumn).getType()));
- } else if (sinkColumn instanceof SqlMetadataColumn) {
- unresolvedSinkColumn =
- toUnresolvedMetadataColumn((SqlMetadataColumn) sinkColumn);
-
- regularAndMetadataFieldNamesToTypes.put(
- name, toRelDataType(((SqlMetadataColumn) sinkColumn).getType()));
- } else if (sinkColumn instanceof SqlComputedColumn) {
+ final UnresolvedColumn unresolvedSinkColumn;
+ final RelDataType relDataType;
+ if (column instanceof SqlRegularColumn) {
+ unresolvedSinkColumn = toUnresolvedPhysicalColumn((SqlRegularColumn) column);
+ relDataType = toRelDataType(((SqlRegularColumn) column).getType());
+ } else if (column instanceof SqlMetadataColumn) {
+ unresolvedSinkColumn = toUnresolvedMetadataColumn((SqlMetadataColumn) column);
+ relDataType = toRelDataType(((SqlMetadataColumn) column).getType());
+ } else if (column instanceof SqlComputedColumn) {
+ final SqlComputedColumn computedColumn = (SqlComputedColumn) column;
final SqlNode validatedExpr =
sqlValidator.validateParameterizedExpression(
- ((SqlComputedColumn) sinkColumn).getExpr(),
- regularAndMetadataFieldNamesToTypes);
+ computedColumn.getExpr(), regularAndMetadataFieldNamesToTypes);
unresolvedSinkColumn =
- toUnresolvedComputedColumn(
- (SqlComputedColumn) sinkColumn, validatedExpr);
-
- computeFieldNamesToTypes.put(
- name, sqlValidator.getValidatedNodeType(validatedExpr));
+ toUnresolvedComputedColumn(computedColumn, validatedExpr);
+ relDataType = sqlValidator.getValidatedNodeType(validatedExpr);
} else {
- throw new ValidationException("Unsupported column type: " + sinkColumn);
+ throw new ValidationException("Unsupported column type: " + column);
}
+ regularAndMetadataFieldNamesToTypes.put(name, relDataType);
+
if (sourceSchemaCols.containsKey(name)) {
// If the column is already defined in the source schema, then check if
// the types are compatible.
@@ -334,6 +329,14 @@ public class MergeTableAsUtil {
columns.putAll(sourceSchemaCols);
}
+ private SqlTableColumn toSqlTableColumn(SqlNode sinkColumn) {
+ if (sinkColumn instanceof SqlTableColumn) {
+ return (SqlTableColumn) sinkColumn;
+ } else {
+ return ((SqlTableColumnPosition) sinkColumn).getColumn();
+ }
+ }
+
/** Reorders the columns from the source schema based on the columns identifiers list. */
private void reorderColumns(List<SqlNode> identifiers, List<UnresolvedColumn> sourceCols) {
Map<String, UnresolvedColumn> sinkSchemaCols = new LinkedHashMap<>();
@@ -431,13 +434,9 @@ public class MergeTableAsUtil {
}
private void setWatermark(SqlWatermark sqlWatermark) {
- Map<String, RelDataType> accessibleFieldNamesToTypes =
- new LinkedHashMap() {
- {
- putAll(regularAndMetadataFieldNamesToTypes);
- putAll(computeFieldNamesToTypes);
- }
- };
+ final Map<String, RelDataType> accessibleFieldNamesToTypes =
+ new LinkedHashMap<>(regularAndMetadataFieldNamesToTypes);
+ accessibleFieldNamesToTypes.putAll(computeFieldNamesToTypes);
addWatermarks(
Collections.singletonList(sqlWatermark), accessibleFieldNamesToTypes, false);
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableAddDistributionConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableAddDistributionConverter.java
index bc9607543be..f66777e84c6 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableAddDistributionConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableAddDistributionConverter.java
@@ -57,7 +57,7 @@ public class SqlAlterTableAddDistributionConverter
if (oldDistribution.isPresent()) {
throw new ValidationException(
String.format(
- "%sThe base table has already defined the distribution `%s`. "
+ "%sThe current table has already defined the distribution '%s'. "
+ "You can modify it or drop it before adding a new one.",
EX_MSG_PREFIX, oldDistribution.get()));
}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaAddConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaAddConverter.java
index 3e6dc2793cc..68575a63a09 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaAddConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaAddConverter.java
@@ -19,7 +19,6 @@
package org.apache.flink.table.planner.operations.converters.table;
import org.apache.flink.sql.parser.ddl.SqlAlterTableAdd;
-import org.apache.flink.sql.parser.ddl.SqlAlterTableSchema;
import org.apache.flink.table.catalog.ResolvedCatalogTable;
import org.apache.flink.table.planner.operations.converters.SchemaAddConverter;
import org.apache.flink.table.planner.operations.converters.SchemaConverter;
@@ -32,9 +31,7 @@ public class SqlAlterTableSchemaAddConverter
extends SqlAlterTableSchemaConverter<SqlAlterTableAdd> {
@Override
protected SchemaConverter createSchemaConverter(
- SqlAlterTableSchema alterTableSchema,
- ResolvedCatalogTable oldTable,
- ConvertContext context) {
+ ResolvedCatalogTable oldTable, ConvertContext context) {
return new SchemaAddConverter(oldTable, context);
}
}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaConverter.java
index 51be19ad381..05901373a30 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaConverter.java
@@ -32,7 +32,7 @@ public abstract class SqlAlterTableSchemaConverter<T extends SqlAlterTableSchema
@Override
protected Operation convertToOperation(
T alterTableSchema, ResolvedCatalogTable oldTable, ConvertContext context) {
- SchemaConverter converter = createSchemaConverter(alterTableSchema, oldTable, context);
+ SchemaConverter converter = createSchemaConverter(oldTable, context);
converter.updateColumn(alterTableSchema.getColumnPositions().getList());
alterTableSchema.getWatermark().ifPresent(converter::updateWatermark);
alterTableSchema.getFullConstraint().ifPresent(converter::updatePrimaryKey);
@@ -46,7 +46,5 @@ public abstract class SqlAlterTableSchemaConverter<T extends SqlAlterTableSchema
}
protected abstract SchemaConverter createSchemaConverter(
- SqlAlterTableSchema alterTableSchema,
- ResolvedCatalogTable oldTable,
- ConvertContext context);
+ ResolvedCatalogTable oldTable, ConvertContext context);
}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaModifyConverter.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaModifyConverter.java
index 31a1d612f0e..12aaabb5a32 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaModifyConverter.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/table/SqlAlterTableSchemaModifyConverter.java
@@ -19,7 +19,6 @@
package org.apache.flink.table.planner.operations.converters.table;
import org.apache.flink.sql.parser.ddl.SqlAlterTableModify;
-import org.apache.flink.sql.parser.ddl.SqlAlterTableSchema;
import org.apache.flink.table.catalog.ResolvedCatalogTable;
import org.apache.flink.table.planner.operations.converters.SchemaModifyConverter;
@@ -31,9 +30,7 @@ public class SqlAlterTableSchemaModifyConverter
extends SqlAlterTableSchemaConverter<SqlAlterTableModify> {
@Override
protected SchemaModifyConverter createSchemaConverter(
- SqlAlterTableSchema alterTableSchema,
- ResolvedCatalogTable oldTable,
- ConvertContext context) {
+ ResolvedCatalogTable oldTable, ConvertContext context) {
return new SchemaModifyConverter(oldTable, context);
}
}
diff --git a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/utils/MaterializedTableUtils.java b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/utils/MaterializedTableUtils.java
index 92d70036707..07ab025cfb8 100644
--- a/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/utils/MaterializedTableUtils.java
+++ b/flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/utils/MaterializedTableUtils.java
@@ -19,24 +19,41 @@
package org.apache.flink.table.planner.utils;
import org.apache.flink.annotation.Internal;
+import org.apache.flink.sql.parser.ddl.SqlAlterMaterializedTableSchema;
import org.apache.flink.sql.parser.ddl.SqlRefreshMode;
+import org.apache.flink.sql.parser.ddl.SqlTableColumn.SqlMetadataColumn;
+import org.apache.flink.sql.parser.ddl.SqlTableColumn.SqlRegularColumn;
+import org.apache.flink.sql.parser.ddl.position.SqlTableColumnPosition;
import org.apache.flink.table.api.ValidationException;
import org.apache.flink.table.catalog.CatalogMaterializedTable.LogicalRefreshMode;
import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshMode;
import org.apache.flink.table.catalog.Column;
import org.apache.flink.table.catalog.IntervalFreshness;
+import org.apache.flink.table.catalog.ResolvedCatalogMaterializedTable;
import org.apache.flink.table.catalog.ResolvedSchema;
+import org.apache.flink.table.planner.operations.PlannerQueryOperation;
+import org.apache.flink.table.planner.operations.converters.SqlNodeConverter.ConvertContext;
import org.apache.calcite.sql.SqlIntervalLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlNodeList;
import org.apache.calcite.sql.type.SqlTypeFamily;
import java.util.ArrayList;
+import java.util.HashSet;
import java.util.List;
+import java.util.Set;
/** The utils for materialized table. */
@Internal
public class MaterializedTableUtils {
+ private static final String PERSISTED_COLUMN_NOT_USED_IN_QUERY =
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n"
+ + "Invalid schema change. All persisted (physical and metadata) columns "
+ + "in the schema part need to be present in the query part.\n"
+ + "However, %s column `%s` could not be found in the query.";
+
public static IntervalFreshness getMaterializedTableFreshness(
SqlIntervalLiteral sqlIntervalLiteral) {
if (sqlIntervalLiteral.signum() < 0) {
@@ -132,4 +149,57 @@ public class MaterializedTableUtils {
return newAddedColumns;
}
+
+ public static void validatePersistedColumnsUsedByQuery(
+ ResolvedCatalogMaterializedTable oldTable,
+ SqlAlterMaterializedTableSchema alterTableSchema,
+ ConvertContext context) {
+ final SqlNodeList sqlNodeList = alterTableSchema.getColumnPositions();
+ if (sqlNodeList.isEmpty()) {
+ return;
+ }
+
+ final SqlNode originalQuery =
+ context.getFlinkPlanner().parser().parse(oldTable.getOriginalQuery());
+ final SqlNode validateQuery = context.getSqlValidator().validate(originalQuery);
+ final PlannerQueryOperation queryOperation =
+ new PlannerQueryOperation(
+ context.toRelRoot(validateQuery).project(),
+ () -> context.toQuotedSqlString(validateQuery));
+
+ validatePersistedColumnsUsedByQuery(sqlNodeList, queryOperation.getResolvedSchema());
+ }
+
+ public static void validatePersistedColumnsUsedByQuery(
+ SqlNodeList columnPositions, ResolvedSchema querySchema) {
+ final Set<String> querySchemaColumnNames = new HashSet<>(querySchema.getColumnNames());
+ for (SqlNode column : columnPositions) {
+ throwIfPersistedColumnNotUsedByQuery(column, querySchemaColumnNames);
+ }
+ }
+
+ private static void throwIfPersistedColumnNotUsedByQuery(
+ SqlNode column, Set<String> querySchemaColumnNames) {
+ if (column instanceof SqlRegularColumn) {
+ SqlRegularColumn physicalColumn = (SqlRegularColumn) column;
+ String columnName = physicalColumn.getName().getSimple();
+ if (!querySchemaColumnNames.contains(columnName)) {
+ throwPersistedColumnNotUsedException("physical", columnName);
+ }
+ } else if (column instanceof SqlMetadataColumn) {
+ SqlMetadataColumn metadataColumn = (SqlMetadataColumn) column;
+ String columnName = metadataColumn.getName().getSimple();
+ if (!metadataColumn.isVirtual() && !querySchemaColumnNames.contains(columnName)) {
+ throwPersistedColumnNotUsedException("metadata persisted", columnName);
+ }
+ } else if (column instanceof SqlTableColumnPosition) {
+ throwIfPersistedColumnNotUsedByQuery(
+ ((SqlTableColumnPosition) column).getColumn(), querySchemaColumnNames);
+ }
+ }
+
+ private static void throwPersistedColumnNotUsedException(String type, String columnName) {
+ throw new ValidationException(
+ String.format(PERSISTED_COLUMN_NOT_USED_IN_QUERY, type, columnName));
+ }
}
diff --git a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlDdlToOperationConverterTest.java b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlDdlToOperationConverterTest.java
index 338f215e539..c88f367ea2c 100644
--- a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlDdlToOperationConverterTest.java
+++ b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlDdlToOperationConverterTest.java
@@ -1542,9 +1542,9 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
"alter materialized table cat1.db1.tb2 add distribution into 3 buckets"))
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
- "Materialized table `cat1`.`db1`.`tb2` has already defined "
- + "the distribution `DISTRIBUTED BY HASH(`a`) INTO 1 BUCKETS`."
- + " You can modify it or drop it before adding a new one.");
+ "The current materialized table has already defined the distribution "
+ + "`DISTRIBUTED BY HASH(`a`) INTO 1 BUCKETS`. "
+ + "You can modify it or drop it before adding a new one.");
}
@Test
@@ -1604,7 +1604,7 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
// try to add a column with duplicated name
assertThatThrownBy(() -> parse("alter table tb1 add a bigint"))
.isInstanceOf(ValidationException.class)
- .hasMessageContaining("Try to add a column `a` which already exists in the table.");
+ .hasMessageContaining("Column `a` already exists in the table.");
// try to add multiple columns with duplicated column name
assertThatThrownBy(() -> parse("alter table tb1 add (x array<string>, x string)"))
@@ -1775,7 +1775,7 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
assertThatThrownBy(() -> parse("alter table tb1 add primary key(c) not enforced"))
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
- "The base table has already defined the primary key constraint [`a`]. "
+ "The current table has already defined the primary key constraint [`a`]. "
+ "You might want to drop it before adding a new one.");
assertThatThrownBy(
@@ -1784,7 +1784,7 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
"alter table tb1 add x string not null primary key not enforced"))
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
- "The base table has already defined the primary key constraint [`a`]. "
+ "The current table has already defined the primary key constraint [`a`]. "
+ "You might want to drop it before adding a new one");
// the original table has composite pk
@@ -1793,7 +1793,7 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
assertThatThrownBy(() -> parse("alter table tb2 add primary key(c) not enforced"))
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
- "The base table has already defined the primary key constraint [`a`, `b`]. "
+ "The current table has already defined the primary key constraint [`a`, `b`]. "
+ "You might want to drop it before adding a new one");
assertThatThrownBy(
@@ -1802,7 +1802,7 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
"alter table tb2 add x string not null primary key not enforced"))
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
- "The base table has already defined the primary key constraint [`a`, `b`]. "
+ "The current table has already defined the primary key constraint [`a`, `b`]. "
+ "You might want to drop it before adding a new one");
// the original table does not define pk
@@ -1946,7 +1946,7 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
assertThatThrownBy(() -> parse("alter table tb2 add watermark for ts as ts"))
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
- "The base table has already defined the watermark strategy "
+ "The current table has already defined the watermark strategy "
+ "`ts` AS ts - interval '5' seconds. "
+ "You might want to drop it before adding a new one.");
checkAlterNonExistTable("alter table %s nonexistent add watermark for ts as ts");
@@ -2047,8 +2047,7 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
// modify nonexistent column name
assertThatThrownBy(() -> parse("alter table tb1 modify x bigint"))
.isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "Try to modify a column `x` which does not exist in the table.");
+ .hasMessageContaining("Column `x` does not exist in the table.");
// refer to nonexistent column name
assertThatThrownBy(() -> parse("alter table tb1 modify a bigint after x"))
@@ -2272,7 +2271,7 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
"alter table tb1 modify constraint ct primary key (b) not enforced"))
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
- "The base table does not define any primary key constraint. You might want to add a new one.");
+ "The current table does not define any primary key constraint. You might want to add a new one.");
prepareTable("tb2", 1);
@@ -2432,7 +2431,7 @@ class SqlDdlToOperationConverterTest extends SqlNodeToOperationConversionTestBas
"alter table tb1 modify watermark for a as to_timestamp(a) - interval '1' minute"))
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
- "The base table does not define any watermark. You might want to add a new one.");
+ "The current table does not define any watermark. You might want to add a new one.");
prepareTable("tb2", true);
diff --git a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlMaterializedTableNodeToOperationConverterTest.java b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlMaterializedTableNodeToOperationConverterTest.java
index fdfbb8ab190..b1db977e241 100644
--- a/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlMaterializedTableNodeToOperationConverterTest.java
+++ b/flink-table/flink-table-planner/src/test/java/org/apache/flink/table/planner/operations/SqlMaterializedTableNodeToOperationConverterTest.java
@@ -26,6 +26,7 @@ import org.apache.flink.table.api.ValidationException;
import org.apache.flink.table.catalog.CatalogMaterializedTable;
import org.apache.flink.table.catalog.CatalogMaterializedTable.LogicalRefreshMode;
import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshStatus;
import org.apache.flink.table.catalog.CatalogTable;
import org.apache.flink.table.catalog.Column;
import org.apache.flink.table.catalog.IntervalFreshness;
@@ -41,6 +42,7 @@ import org.apache.flink.table.catalog.exceptions.TableAlreadyExistException;
import org.apache.flink.table.catalog.exceptions.TableNotExistException;
import org.apache.flink.table.operations.Operation;
import org.apache.flink.table.operations.materializedtable.AlterMaterializedTableAsQueryOperation;
+import org.apache.flink.table.operations.materializedtable.AlterMaterializedTableChangeOperation;
import org.apache.flink.table.operations.materializedtable.AlterMaterializedTableRefreshOperation;
import org.apache.flink.table.operations.materializedtable.AlterMaterializedTableResumeOperation;
import org.apache.flink.table.operations.materializedtable.AlterMaterializedTableSuspendOperation;
@@ -79,15 +81,13 @@ class SqlMaterializedTableNodeToOperationConverterTest
void before() throws TableAlreadyExistException, DatabaseNotExistException {
super.before();
final ObjectPath path3 = new ObjectPath(catalogManager.getCurrentDatabase(), "t3");
- final Schema tableSchema =
- Schema.newBuilder()
- .fromResolvedSchema(
- ResolvedSchema.of(
- Column.physical("a", DataTypes.BIGINT().notNull()),
- Column.physical("b", DataTypes.VARCHAR(Integer.MAX_VALUE)),
- Column.physical("c", DataTypes.INT()),
- Column.physical("d", DataTypes.VARCHAR(Integer.MAX_VALUE))))
- .build();
+ final ResolvedSchema t3TableSchema =
+ ResolvedSchema.of(
+ Column.physical("a", DataTypes.BIGINT().notNull()),
+ Column.physical("b", DataTypes.VARCHAR(Integer.MAX_VALUE)),
+ Column.physical("c", DataTypes.INT()),
+ Column.physical("d", DataTypes.VARCHAR(Integer.MAX_VALUE)));
+ final Schema tableSchema = Schema.newBuilder().fromResolvedSchema(t3TableSchema).build();
Map<String, String> options = new HashMap<>();
options.put("connector", "COLLECTION");
final CatalogTable catalogTable =
@@ -100,7 +100,7 @@ class SqlMaterializedTableNodeToOperationConverterTest
catalog.createTable(path3, catalogTable, true);
// create materialized table
- final String sql =
+ final String sqlWithConstraint =
"CREATE MATERIALIZED TABLE base_mtbl (\n"
+ " CONSTRAINT ct1 PRIMARY KEY(a) NOT ENFORCED"
+ ")\n"
@@ -113,10 +113,40 @@ class SqlMaterializedTableNodeToOperationConverterTest
+ "FRESHNESS = INTERVAL '30' SECOND\n"
+ "REFRESH_MODE = FULL\n"
+ "AS SELECT * FROM t1";
- final ObjectPath path4 = new ObjectPath(catalogManager.getCurrentDatabase(), "base_mtbl");
+ createMaterializedTableInCatalog(sqlWithConstraint, "base_mtbl");
+
+ // MATERIALIZED TABLE with WATERMARK
+ final String sqlWithWatermark =
+ "CREATE MATERIALIZED TABLE base_mtbl_with_watermark (\n"
+ + " t AS current_timestamp,"
+ + " CONSTRAINT ct1 PRIMARY KEY(a) NOT ENFORCED,"
+ + " WATERMARK FOR t as current_timestamp - INTERVAL '5' SECOND"
+ + ")\n"
+ + "COMMENT 'materialized table comment'\n"
+ + "PARTITIONED BY (a, d)\n"
+ + "WITH (\n"
+ + " 'connector' = 'filesystem', \n"
+ + " 'format' = 'json'\n"
+ + ")\n"
+ + "FRESHNESS = INTERVAL '30' SECOND\n"
+ + "REFRESH_MODE = FULL\n"
+ + "AS SELECT t1.* FROM t1";
+ createMaterializedTableInCatalog(sqlWithWatermark, "base_mtbl_with_watermark");
- CreateMaterializedTableOperation operation = (CreateMaterializedTableOperation) parse(sql);
- catalog.createTable(path4, operation.getCatalogMaterializedTable(), true);
+ // MATERIALIZED TABLE without constraint
+ final String sqlWithoutConstraint =
+ "CREATE MATERIALIZED TABLE base_mtbl_without_constraint "
+ + "COMMENT 'materialized table comment'\n"
+ + "PARTITIONED BY (a, d)\n"
+ + "WITH (\n"
+ + " 'connector' = 'filesystem', \n"
+ + " 'format' = 'json'\n"
+ + ")\n"
+ + "FRESHNESS = INTERVAL '30' SECOND\n"
+ + "REFRESH_MODE = FULL\n"
+ + "AS SELECT t1.* FROM t1";
+
+ createMaterializedTableInCatalog(sqlWithoutConstraint, "base_mtbl_without_constraint");
}
@Test
@@ -134,35 +164,9 @@ class SqlMaterializedTableNodeToOperationConverterTest
+ "FRESHNESS = INTERVAL '30' SECOND\n"
+ "REFRESH_MODE = FULL\n"
+ "AS SELECT * FROM t1";
- Operation operation = parse(sql);
- assertThat(operation).isInstanceOf(CreateMaterializedTableOperation.class);
- CreateMaterializedTableOperation op = (CreateMaterializedTableOperation) operation;
- ResolvedCatalogMaterializedTable materializedTable = op.getCatalogMaterializedTable();
-
- Map<String, String> options = Map.of("connector", "filesystem", "format", "json");
- CatalogMaterializedTable expected =
- CatalogMaterializedTable.newBuilder()
- .schema(
- Schema.newBuilder()
- .column("a", DataTypes.BIGINT().notNull())
- .column("b", DataTypes.VARCHAR(Integer.MAX_VALUE))
- .column("c", DataTypes.INT())
- .column("d", DataTypes.VARCHAR(Integer.MAX_VALUE))
- .primaryKeyNamed("ct1", Collections.singletonList("a"))
- .build())
- .comment("materialized table comment")
- .options(options)
- .partitionKeys(Arrays.asList("a", "d"))
- .freshness(IntervalFreshness.ofSecond("30"))
- .logicalRefreshMode(CatalogMaterializedTable.LogicalRefreshMode.FULL)
- .refreshMode(RefreshMode.FULL)
- .refreshStatus(CatalogMaterializedTable.RefreshStatus.INITIALIZING)
- .originalQuery("SELECT *\nFROM `t1`")
- .expandedQuery(
- "SELECT `t1`.`a`, `t1`.`b`, `t1`.`c`, `t1`.`d`\n"
- + "FROM `builtin`.`default`.`t1` AS `t1`")
- .build();
+ ResolvedCatalogMaterializedTable materializedTable =
+ createResolvedCatalogMaterializedTable(sql);
final IntervalFreshness resolvedFreshness = materializedTable.getDefinitionFreshness();
assertThat(resolvedFreshness).isEqualTo(IntervalFreshness.ofSecond("30"));
@@ -170,6 +174,13 @@ class SqlMaterializedTableNodeToOperationConverterTest
final RefreshMode resolvedRefreshMode = materializedTable.getRefreshMode();
assertThat(resolvedRefreshMode).isSameAs(RefreshMode.FULL);
+ final CatalogMaterializedTable expected =
+ getDefaultMaterializedTableBuilder()
+ .freshness(IntervalFreshness.ofSecond("30"))
+ .logicalRefreshMode(LogicalRefreshMode.FULL)
+ .refreshMode(RefreshMode.FULL)
+ .refreshStatus(RefreshStatus.INITIALIZING)
+ .build();
assertThat(materializedTable.getOrigin()).isEqualTo(expected);
}
@@ -187,36 +198,8 @@ class SqlMaterializedTableNodeToOperationConverterTest
+ ")\n"
+ "REFRESH_MODE = FULL\n"
+ "AS SELECT * FROM t1";
- Operation operation = parse(sql);
- assertThat(operation).isInstanceOf(CreateMaterializedTableOperation.class);
-
- CreateMaterializedTableOperation op = (CreateMaterializedTableOperation) operation;
- ResolvedCatalogMaterializedTable materializedTable = op.getCatalogMaterializedTable();
- assertThat(materializedTable).isInstanceOf(ResolvedCatalogMaterializedTable.class);
-
- Map<String, String> options = Map.of("connector", "filesystem", "format", "json");
-
- CatalogMaterializedTable expected =
- CatalogMaterializedTable.newBuilder()
- .schema(
- Schema.newBuilder()
- .column("a", DataTypes.BIGINT().notNull())
- .column("b", DataTypes.VARCHAR(Integer.MAX_VALUE))
- .column("c", DataTypes.INT())
- .column("d", DataTypes.VARCHAR(Integer.MAX_VALUE))
- .primaryKeyNamed("ct1", Collections.singletonList("a"))
- .build())
- .comment("materialized table comment")
- .options(options)
- .partitionKeys(Arrays.asList("a", "d"))
- .logicalRefreshMode(LogicalRefreshMode.FULL)
- .refreshMode(RefreshMode.FULL)
- .refreshStatus(CatalogMaterializedTable.RefreshStatus.INITIALIZING)
- .originalQuery("SELECT *\nFROM `t1`")
- .expandedQuery(
- "SELECT `t1`.`a`, `t1`.`b`, `t1`.`c`, `t1`.`d`\n"
- + "FROM `builtin`.`default`.`t1` AS `t1`")
- .build();
+ ResolvedCatalogMaterializedTable materializedTable =
+ createResolvedCatalogMaterializedTable(sql);
// The resolved freshness should default to 1 minute
final IntervalFreshness resolvedFreshness = materializedTable.getDefinitionFreshness();
@@ -225,6 +208,12 @@ class SqlMaterializedTableNodeToOperationConverterTest
final RefreshMode resolvedRefreshMode = materializedTable.getRefreshMode();
assertThat(resolvedRefreshMode).isSameAs(RefreshMode.FULL);
+ final CatalogMaterializedTable expected =
+ getDefaultMaterializedTableBuilder()
+ .logicalRefreshMode(LogicalRefreshMode.FULL)
+ .refreshMode(RefreshMode.FULL)
+ .refreshStatus(RefreshStatus.INITIALIZING)
+ .build();
assertThat(materializedTable.getOrigin()).isEqualTo(expected);
}
@@ -241,38 +230,16 @@ class SqlMaterializedTableNodeToOperationConverterTest
+ " 'format' = 'json'\n"
+ ")\n"
+ "AS SELECT * FROM t1";
- Operation operation = parse(sql);
- assertThat(operation).isInstanceOf(CreateMaterializedTableOperation.class);
-
- CreateMaterializedTableOperation op = (CreateMaterializedTableOperation) operation;
- ResolvedCatalogMaterializedTable materializedTable = op.getCatalogMaterializedTable();
- assertThat(materializedTable).isInstanceOf(ResolvedCatalogMaterializedTable.class);
-
- Map<String, String> options = Map.of("connector", "filesystem", "format", "json");
-
- CatalogMaterializedTable expected =
- CatalogMaterializedTable.newBuilder()
- .schema(
- Schema.newBuilder()
- .column("a", DataTypes.BIGINT().notNull())
- .column("b", DataTypes.VARCHAR(Integer.MAX_VALUE))
- .column("c", DataTypes.INT())
- .column("d", DataTypes.VARCHAR(Integer.MAX_VALUE))
- .primaryKeyNamed("ct1", Collections.singletonList("a"))
- .build())
- .comment("materialized table comment")
- .options(options)
- .partitionKeys(Arrays.asList("a", "d"))
- .logicalRefreshMode(LogicalRefreshMode.AUTOMATIC)
- .refreshStatus(CatalogMaterializedTable.RefreshStatus.INITIALIZING)
- .originalQuery("SELECT *\nFROM `t1`")
- .expandedQuery(
- "SELECT `t1`.`a`, `t1`.`b`, `t1`.`c`, `t1`.`d`\n"
- + "FROM `builtin`.`default`.`t1` AS `t1`")
- .build();
+ ResolvedCatalogMaterializedTable materializedTable =
+ createResolvedCatalogMaterializedTable(sql);
final IntervalFreshness resolvedFreshness = materializedTable.getDefinitionFreshness();
assertThat(resolvedFreshness).isEqualTo(IntervalFreshness.ofMinute("3"));
+ final CatalogMaterializedTable expected =
+ getDefaultMaterializedTableBuilder()
+ .logicalRefreshMode(LogicalRefreshMode.AUTOMATIC)
+ .refreshStatus(RefreshStatus.INITIALIZING)
+ .build();
assertThat(materializedTable.getOrigin()).isEqualTo(expected);
}
@@ -298,11 +265,8 @@ class SqlMaterializedTableNodeToOperationConverterTest
+ "FRESHNESS = INTERVAL '30' SECOND\n"
+ "REFRESH_MODE = FULL\n"
+ "AS SELECT a, f1, f2 FROM t1, LATERAL TABLE(myFunc(b)) as T(f1, f2)";
- Operation operation = parse(sql);
- assertThat(operation).isInstanceOf(CreateMaterializedTableOperation.class);
- CreateMaterializedTableOperation createOperation =
- (CreateMaterializedTableOperation) operation;
+ CreateMaterializedTableOperation createOperation = createMaterializedTableOperation(sql);
assertThat(createOperation.getCatalogMaterializedTable().getExpandedQuery())
.isEqualTo(
@@ -323,11 +287,7 @@ class SqlMaterializedTableNodeToOperationConverterTest
final String sql =
"CREATE MATERIALIZED TABLE mtbl1 \n"
+ "AS SELECT * FROM t1, LATERAL TABLE(myFunc(b))";
- Operation operation = parse(sql);
- assertThat(operation).isInstanceOf(CreateMaterializedTableOperation.class);
-
- CreateMaterializedTableOperation createOperation =
- (CreateMaterializedTableOperation) operation;
+ CreateMaterializedTableOperation createOperation = createMaterializedTableOperation(sql);
assertThat(createOperation.getCatalogMaterializedTable().getExpandedQuery())
.isEqualTo(
@@ -343,15 +303,12 @@ class SqlMaterializedTableNodeToOperationConverterTest
"CREATE MATERIALIZED TABLE mtbl1\n"
+ "FRESHNESS = INTERVAL '30' SECOND\n"
+ "AS SELECT * FROM t1";
- Operation operation = parse(sql);
- assertThat(operation).isInstanceOf(CreateMaterializedTableOperation.class);
-
- CreateMaterializedTableOperation op = (CreateMaterializedTableOperation) operation;
- ResolvedCatalogMaterializedTable materializedTable = op.getCatalogMaterializedTable();
+ ResolvedCatalogMaterializedTable materializedTable =
+ createResolvedCatalogMaterializedTable(sql);
assertThat(materializedTable.getLogicalRefreshMode())
- .isEqualTo(CatalogMaterializedTable.LogicalRefreshMode.AUTOMATIC);
- assertThat(materializedTable.getRefreshMode()).isEqualTo(RefreshMode.CONTINUOUS);
+ .isSameAs(LogicalRefreshMode.AUTOMATIC);
+ assertThat(materializedTable.getRefreshMode()).isSameAs(RefreshMode.CONTINUOUS);
// test continuous mode by manual specify
final String sql2 =
@@ -359,16 +316,12 @@ class SqlMaterializedTableNodeToOperationConverterTest
+ "FRESHNESS = INTERVAL '30' DAY\n"
+ "REFRESH_MODE = CONTINUOUS\n"
+ "AS SELECT * FROM t1";
- Operation operation2 = parse(sql2);
- assertThat(operation2).isInstanceOf(CreateMaterializedTableOperation.class);
-
- CreateMaterializedTableOperation op2 = (CreateMaterializedTableOperation) operation2;
- ResolvedCatalogMaterializedTable materializedTable2 = op2.getCatalogMaterializedTable();
+ ResolvedCatalogMaterializedTable materializedTable2 =
+ createResolvedCatalogMaterializedTable(sql2);
assertThat(materializedTable2.getLogicalRefreshMode())
- .isEqualTo(CatalogMaterializedTable.LogicalRefreshMode.CONTINUOUS);
- assertThat(materializedTable2.getRefreshMode())
- .isEqualTo(CatalogMaterializedTable.RefreshMode.CONTINUOUS);
+ .isSameAs(LogicalRefreshMode.CONTINUOUS);
+ assertThat(materializedTable2.getRefreshMode()).isSameAs(RefreshMode.CONTINUOUS);
}
@Test
@@ -378,15 +331,12 @@ class SqlMaterializedTableNodeToOperationConverterTest
"CREATE MATERIALIZED TABLE mtbl1\n"
+ "FRESHNESS = INTERVAL '1' DAY\n"
+ "AS SELECT * FROM t1";
- Operation operation = parse(sql);
- assertThat(operation).isInstanceOf(CreateMaterializedTableOperation.class);
-
- CreateMaterializedTableOperation op = (CreateMaterializedTableOperation) operation;
- ResolvedCatalogMaterializedTable materializedTable = op.getCatalogMaterializedTable();
+ ResolvedCatalogMaterializedTable materializedTable =
+ createResolvedCatalogMaterializedTable(sql);
assertThat(materializedTable.getLogicalRefreshMode())
- .isEqualTo(CatalogMaterializedTable.LogicalRefreshMode.AUTOMATIC);
- assertThat(materializedTable.getRefreshMode()).isEqualTo(RefreshMode.FULL);
+ .isSameAs(LogicalRefreshMode.AUTOMATIC);
+ assertThat(materializedTable.getRefreshMode()).isSameAs(RefreshMode.FULL);
// test full mode by manual specify
final String sql2 =
@@ -394,171 +344,20 @@ class SqlMaterializedTableNodeToOperationConverterTest
+ "FRESHNESS = INTERVAL '30' SECOND\n"
+ "REFRESH_MODE = FULL\n"
+ "AS SELECT * FROM t1";
- Operation operation2 = parse(sql2);
- assertThat(operation2).isInstanceOf(CreateMaterializedTableOperation.class);
-
- CreateMaterializedTableOperation op2 = (CreateMaterializedTableOperation) operation2;
- ResolvedCatalogMaterializedTable materializedTable2 = op2.getCatalogMaterializedTable();
-
- assertThat(materializedTable2.getLogicalRefreshMode())
- .isEqualTo(CatalogMaterializedTable.LogicalRefreshMode.FULL);
- assertThat(materializedTable2.getRefreshMode()).isEqualTo(RefreshMode.FULL);
- final String sql3 =
- "CREATE MATERIALIZED TABLE mtbl1\n"
- + "FRESHNESS = INTERVAL '40' MINUTE\n"
- + "REFRESH_MODE = FULL\n"
- + "AS SELECT * FROM t1";
- assertThatThrownBy(() -> parse(sql3))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "In full refresh mode, only freshness that are factors of 60 are currently supported when the time unit is MINUTE.");
-
- final String sql4 =
- "CREATE MATERIALIZED TABLE mtbl1\n"
- + "FRESHNESS = INTERVAL '40' MINUTE\n"
- + "AS SELECT * FROM t1";
-
- assertThatThrownBy(() -> parse(sql4))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "In full refresh mode, only freshness that are factors of 60 are currently supported when the time unit is MINUTE.");
- }
-
- @Test
- void testCreateMaterializedTableWithInvalidPrimaryKey() {
- // test unsupported constraint
- final String sql =
- "CREATE MATERIALIZED TABLE mtbl1 (\n"
- + " CONSTRAINT ct1 UNIQUE(a) NOT ENFORCED"
- + ")\n"
- + "FRESHNESS = INTERVAL '30' SECOND\n"
- + "AS SELECT * FROM t1";
-
- assertThatThrownBy(() -> parse(sql))
- .isInstanceOf(SqlValidateException.class)
- .hasMessageContaining("UNIQUE constraint is not supported yet");
-
- // test primary key not defined in source table
- final String sql2 =
- "CREATE MATERIALIZED TABLE mtbl1 (\n"
- + " CONSTRAINT ct1 PRIMARY KEY(e) NOT ENFORCED"
- + ")\n"
- + "FRESHNESS = INTERVAL '30' SECOND\n"
- + "AS SELECT * FROM t1";
-
- assertThatThrownBy(() -> parse(sql2))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "Primary key column 'e' is not defined in the schema at line 2, column 31");
-
- // test primary key with nullable source column
- final String sql3 =
- "CREATE MATERIALIZED TABLE mtbl1 (\n"
- + " CONSTRAINT ct1 PRIMARY KEY(d) NOT ENFORCED"
- + ")\n"
- + "FRESHNESS = INTERVAL '30' SECOND\n"
- + "AS SELECT * FROM t1";
-
- assertThatThrownBy(() -> parse(sql3))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining("Invalid primary key 'ct1'. Column 'd' is nullable.");
- }
-
- @Test
- void testCreateMaterializedTableWithInvalidPartitionKey() {
- final String sql =
- "CREATE MATERIALIZED TABLE mtbl1\n"
- + "PARTITIONED BY (a, e)\n"
- + "FRESHNESS = INTERVAL '30' SECOND\n"
- + "REFRESH_MODE = FULL\n"
- + "AS SELECT * FROM t1";
- assertThatThrownBy(() -> parse(sql))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "Partition column 'e' not defined in the query schema. Available columns: ['a', 'b', 'c', 'd']");
+ ResolvedCatalogMaterializedTable materializedTable2 =
+ createResolvedCatalogMaterializedTable(sql2);
- final String sql2 =
- "CREATE MATERIALIZED TABLE mtbl1\n"
- + "PARTITIONED BY (b, c)\n"
- + "WITH (\n"
- + " 'partition.fields.ds.date-formatter' = 'yyyy-MM-dd'\n"
- + ")\n"
- + "FRESHNESS = INTERVAL '30' SECOND\n"
- + "REFRESH_MODE = FULL\n"
- + "AS SELECT * FROM t3";
- assertThatThrownBy(() -> parse(sql2))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "Column 'ds' referenced by materialized table option 'partition.fields.ds.date-formatter' isn't a partition column. Available partition columns: ['b', 'c'].");
-
- final String sql3 =
- "CREATE MATERIALIZED TABLE mtbl1\n"
- + "WITH (\n"
- + " 'partition.fields.c.date-formatter' = 'yyyy-MM-dd'\n"
- + ")\n"
- + "FRESHNESS = INTERVAL '30' SECOND\n"
- + "REFRESH_MODE = FULL\n"
- + "AS SELECT * FROM t3";
- assertThatThrownBy(() -> parse(sql3))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "Column 'c' referenced by materialized table option 'partition.fields.c.date-formatter' isn't a partition column. Available partition columns: [''].");
-
- final String sql4 =
- "CREATE MATERIALIZED TABLE mtbl1\n"
- + "PARTITIONED BY (b, c)\n"
- + "WITH (\n"
- + " 'partition.fields.c.date-formatter' = 'yyyy-MM-dd'\n"
- + ")\n"
- + "FRESHNESS = INTERVAL '30' SECOND\n"
- + "REFRESH_MODE = FULL\n"
- + "AS SELECT * FROM t3";
- assertThatThrownBy(() -> parse(sql4))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "Materialized table option 'partition.fields.c.date-formatter' only supports referring to char, varchar and string type partition column. Column c type is INT.");
- }
-
- @Test
- void testCreateMaterializedTableWithInvalidFreshnessType() {
- // test negative freshness value
- final String sql =
- "CREATE MATERIALIZED TABLE mtbl1\n"
- + "FRESHNESS = INTERVAL -'30' SECOND\n"
- + "REFRESH_MODE = FULL\n"
- + "AS SELECT * FROM t1";
- assertThatThrownBy(() -> parse(sql))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "Materialized table freshness doesn't support negative value.");
-
- // test unsupported freshness type
- final String sql2 =
- "CREATE MATERIALIZED TABLE mtbl1\n"
- + "FRESHNESS = INTERVAL '30' YEAR\n"
- + "AS SELECT * FROM t1";
- assertThatThrownBy(() -> parse(sql2))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "Materialized table freshness only support SECOND, MINUTE, HOUR, DAY as the time unit.");
-
- // test unsupported freshness type
- final String sql3 =
- "CREATE MATERIALIZED TABLE mtbl1\n"
- + "FRESHNESS = INTERVAL '30' DAY TO HOUR\n"
- + "AS SELECT * FROM t1";
- assertThatThrownBy(() -> parse(sql3))
- .isInstanceOf(ValidationException.class)
- .hasMessageContaining(
- "Materialized table freshness only support SECOND, MINUTE, HOUR, DAY as the time unit.");
+ assertThat(materializedTable2.getLogicalRefreshMode()).isSameAs(LogicalRefreshMode.FULL);
+ assertThat(materializedTable2.getRefreshMode()).isSameAs(RefreshMode.FULL);
}
@ParameterizedTest
@MethodSource("testDataForCreateMaterializedTableFailedCase")
- void createMaterializedTableFailedCase(String sql, String expectedErrorMsg) {
- assertThatThrownBy(() -> parse(sql))
- .isInstanceOf(ValidationException.class)
- .hasMessage(expectedErrorMsg);
+ void createMaterializedTableFailedCase(TestSpec spec) {
+ assertThatThrownBy(() -> parse(spec.sql))
+ .as(spec.sql)
+ .isInstanceOf(spec.expectedException)
+ .hasMessageContaining(spec.errMessage);
}
@ParameterizedTest
@@ -568,6 +367,16 @@ class SqlMaterializedTableNodeToOperationConverterTest
assertThat(operation.getCatalogMaterializedTable().getResolvedSchema()).isEqualTo(expected);
}
+ @ParameterizedTest
+ @MethodSource("alterSuccessCase")
+ void createAlterTableSuccessCase(TestSpec testSpec) {
+ AlterMaterializedTableChangeOperation operation =
+ (AlterMaterializedTableChangeOperation) parse(testSpec.sql);
+ CatalogMaterializedTable catalogMaterializedTable = operation.getCatalogMaterializedTable();
+ assertThat(catalogMaterializedTable.getUnresolvedSchema())
+ .hasToString(testSpec.expectedSchema);
+ }
+
@Test
void createMaterializedTableWithWatermark() {
final String sql =
@@ -786,27 +595,12 @@ class SqlMaterializedTableNodeToOperationConverterTest
Map<String, String> options = new HashMap<>();
options.put("connector", "filesystem");
options.put("format", "json");
- CatalogMaterializedTable expected =
- CatalogMaterializedTable.newBuilder()
- .schema(
- Schema.newBuilder()
- .column("a", DataTypes.BIGINT().notNull())
- .column("b", DataTypes.VARCHAR(Integer.MAX_VALUE))
- .column("c", DataTypes.INT())
- .column("d", DataTypes.VARCHAR(Integer.MAX_VALUE))
- .primaryKeyNamed("ct1", Collections.singletonList("a"))
- .build())
- .comment("materialized table comment")
- .options(options)
- .partitionKeys(Arrays.asList("a", "d"))
+ final CatalogMaterializedTable expected =
+ getDefaultMaterializedTableBuilder()
.freshness(IntervalFreshness.ofSecond("30"))
- .logicalRefreshMode(CatalogMaterializedTable.LogicalRefreshMode.FULL)
- .refreshMode(CatalogMaterializedTable.RefreshMode.FULL)
- .refreshStatus(CatalogMaterializedTable.RefreshStatus.INITIALIZING)
- .originalQuery("SELECT *\nFROM `t1`")
- .expandedQuery(
- "SELECT `t1`.`a`, `t1`.`b`, `t1`.`c`, `t1`.`d`\n"
- + "FROM `builtin`.`default`.`t1` AS `t1`")
+ .logicalRefreshMode(LogicalRefreshMode.FULL)
+ .refreshMode(RefreshMode.FULL)
+ .refreshStatus(RefreshStatus.INITIALIZING)
.build();
assertThat(materializedTable.getOrigin()).isEqualTo(expected);
@@ -886,97 +680,285 @@ class SqlMaterializedTableNodeToOperationConverterTest
"f", DataTypes.VARCHAR(Integer.MAX_VALUE))));
}
- private static Collection<Arguments> testDataForCreateMaterializedTableFailedCase() {
- final Collection<Arguments> list = new ArrayList<>();
- list.addAll(create());
- list.addAll(alter());
+ private static Collection<TestSpec> testDataForCreateMaterializedTableFailedCase() {
+ final Collection<TestSpec> list = new ArrayList<>();
+ list.addAll(createWithInvalidSchema());
+ list.addAll(createWithInvalidFreshness());
+ list.addAll(createWithInvalidPartitions());
+ list.addAll(alterWithInvalidSchema());
+ list.addAll(alterQuery());
return list;
}
- private static Collection<Arguments> alter() {
+ private static Collection<TestSpec> alterQuery() {
return List.of(
- Arguments.of(
+ TestSpec.of(
"ALTER MATERIALIZED TABLE base_mtbl AS SELECT a, b FROM t3",
"Failed to modify query because drop column is unsupported. When modifying "
+ "a query, you can only append new columns at the end of original "
+ "schema. The original schema has 4 columns, but the newly derived "
+ "schema from the query has 2 columns."),
- Arguments.of(
+ TestSpec.of(
"ALTER MATERIALIZED TABLE base_mtbl AS SELECT a, b, d, c FROM t3",
"When modifying the query of a materialized table, currently only support "
+ "appending columns at the end of original schema, dropping, "
+ "renaming, and reordering columns are not supported.\n"
+ "Column mismatch at position 2: Original column is [`c` INT], "
+ "but new column is [`d` STRING]."),
- Arguments.of(
+ TestSpec.of(
"ALTER MATERIALIZED TABLE base_mtbl AS SELECT a, b, c, CAST(d AS INT) AS d FROM t3",
"When modifying the query of a materialized table, currently only support "
+ "appending columns at the end of original schema, dropping, "
+ "renaming, and reordering columns are not supported.\n"
+ "Column mismatch at position 3: Original column is [`d` STRING], "
+ "but new column is [`d` INT]."),
- Arguments.of(
+ TestSpec.of(
"ALTER MATERIALIZED TABLE base_mtbl AS SELECT a, b, c, CAST('d' AS STRING) AS d FROM t3",
"When modifying the query of a materialized table, currently only support "
+ "appending columns at the end of original schema, dropping, "
+ "renaming, and reordering columns are not supported.\n"
+ "Column mismatch at position 3: Original column is [`d` STRING], "
+ "but new column is [`d` STRING NOT NULL]."),
- Arguments.of(
+ TestSpec.of(
"ALTER MATERIALIZED TABLE t1 AS SELECT * FROM t1",
- "Only materialized tables support modifying the definition query."));
+ "ALTER MATERIALIZED TABLE for a table is not allowed"));
}
- private static Collection<Arguments> create() {
+ private static List<TestSpec> alterWithInvalidSchema() {
return List.of(
- Arguments.of(
+ TestSpec.of(
+ "ALTER MATERIALIZED TABLE base_mtbl ADD WATERMARK for invalid_column as invalid_column",
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n"
+ + "Invalid column name 'invalid_column' for rowtime attribute in watermark declaration. "
+ + "Available columns are: [a, b, c, d]"),
+ TestSpec.of(
+ "ALTER MATERIALIZED TABLE base_mtbl_with_watermark ADD WATERMARK for t as current_timestamp - INTERVAL '2' SECOND",
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n"
+ + "The current materialized table has already defined the watermark strategy "
+ + "`t` AS CURRENT_TIMESTAMP - INTERVAL '5' SECOND. You might want to drop it before adding a new one."),
+ TestSpec.of(
+ "ALTER MATERIALIZED TABLE base_mtbl ADD `physical_not_used_in_query` BIGINT NOT NULL",
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n"
+ + "Invalid schema change. All persisted (physical and metadata) "
+ + "columns in the schema part need to be present in the query part.\n"
+ + "However, physical column `physical_not_used_in_query` could not be found in the query."),
+ TestSpec.of(
+ "ALTER MATERIALIZED TABLE base_mtbl ADD `a` BIGINT NOT NULL",
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n"
+ + "Column `a` already exists in the materialized table."),
+ TestSpec.of(
+ "ALTER MATERIALIZED TABLE base_mtbl ADD `q` AS `non_existing_column` + 2",
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n"
+ + "Invalid expression for computed column 'q'."),
+ TestSpec.of(
+ "ALTER MATERIALIZED TABLE base_mtbl ADD PRIMARY KEY(c) NOT ENFORCED",
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n"
+ + "The current materialized table has already defined the primary key constraint [`a`]. "
+ + "You might want to drop it before adding a new one."),
+ TestSpec.of(
+ "ALTER MATERIALIZED TABLE base_mtbl ADD (`q` AS current_timestamp AFTER `q2`, `q2` AS current_timestamp AFTER `q`)",
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n"
+ + "Referenced column `q2` by 'AFTER' does not exist in the table."),
+ TestSpec.of(
+ "ALTER MATERIALIZED TABLE base_mtbl ADD `m1` INT METADATA",
+ "Failed to execute ALTER MATERIALIZED TABLE statement.\n"
+ + "Invalid schema change. All persisted (physical and metadata) "
+ + "columns in the schema part need to be present in the query part.\n"
+ + "However, metadata persisted column `m1` could not be found in the query."));
+ }
+
+ private static List<TestSpec> createWithInvalidSchema() {
+ return List.of(
+ TestSpec.of(
"CREATE MATERIALIZED TABLE users_shops (shop_id)"
+ " FRESHNESS = INTERVAL '30' SECOND"
+ " AS SELECT 1 AS shop_id, 2 AS user_id",
"The number of columns in the column list must match the number of columns in the source schema."),
- Arguments.of(
+ TestSpec.of(
"CREATE MATERIALIZED TABLE users_shops (id, name, address)"
+ " FRESHNESS = INTERVAL '30' SECOND"
+ " AS SELECT 1 AS shop_id, 2 AS user_id",
"The number of columns in the column list must match the number of columns in the source schema."),
- Arguments.of(
+ TestSpec.of(
"CREATE MATERIALIZED TABLE users_shops (id, name)"
+ " FRESHNESS = INTERVAL '30' SECOND"
+ " AS SELECT 1 AS shop_id, 2 AS user_id",
"Column 'id' not found in the source schema."),
- Arguments.of(
+ TestSpec.of(
"CREATE MATERIALIZED TABLE users_shops (shop_id STRING, user_id STRING)"
+ " FRESHNESS = INTERVAL '30' SECOND"
+ " AS SELECT 1 AS shop_id, 2 AS user_id",
"Incompatible types for sink column 'shop_id' at position 0. The source column has type 'INT NOT NULL', "
+ "while the target column has type 'STRING'."),
- Arguments.of(
+ TestSpec.of(
"CREATE MATERIALIZED TABLE users_shops (shop_id INT, WATERMARK FOR ts AS `ts` - INTERVAL '5' SECOND)"
+ " FRESHNESS = INTERVAL '30' SECOND"
+ " AS SELECT 1 AS shop_id, 2 AS user_id",
"The rowtime attribute field 'ts' is not defined in the table schema, at line 1, column 67\n"
+ "Available fields: ['shop_id', 'user_id']"),
- Arguments.of(
+ TestSpec.of(
"CREATE MATERIALIZED TABLE users_shops (shop_id INT, user_id INT, PRIMARY KEY(id) NOT ENFORCED)"
+ " FRESHNESS = INTERVAL '30' SECOND"
+ " AS SELECT 1 AS shop_id, 2 AS user_id",
"Primary key column 'id' is not defined in the schema at line 1, column 78"),
- Arguments.of(
+ TestSpec.of(
"CREATE MATERIALIZED TABLE users_shops (WATERMARK FOR ts AS ts - INTERVAL '2' SECOND)"
+ " FRESHNESS = INTERVAL '30' SECOND"
+ " AS SELECT 1 AS shop_id, 2 AS user_id",
"The rowtime attribute field 'ts' is not defined in the table schema, at line 1, column 54\n"
+ "Available fields: ['shop_id', 'user_id']"),
- Arguments.of(
+ TestSpec.of(
"CREATE MATERIALIZED TABLE users_shops (a INT, b INT)"
+ " FRESHNESS = INTERVAL '30' SECOND"
+ " AS SELECT 1 AS shop_id, 2 AS user_id",
"Invalid as physical column 'a' is defined in the DDL, but is not used in a query column."),
- Arguments.of(
+ TestSpec.of(
"CREATE MATERIALIZED TABLE users_shops (shop_id INT, b INT)"
+ " FRESHNESS = INTERVAL '30' SECOND"
+ " AS SELECT 1 AS shop_id, 2 AS user_id",
- "Invalid as physical column 'b' is defined in the DDL, but is not used in a query column."));
+ "Invalid as physical column 'b' is defined in the DDL, but is not used in a query column."),
+ // test unsupported constraint
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1 (\n"
+ + " CONSTRAINT ct1 UNIQUE(a) NOT ENFORCED"
+ + ")\n"
+ + "FRESHNESS = INTERVAL '30' SECOND\n"
+ + "AS SELECT * FROM t1",
+ SqlValidateException.class,
+ "UNIQUE constraint is not supported yet"),
+ // test primary key not defined in source table
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1 (\n"
+ + " CONSTRAINT ct1 PRIMARY KEY(e) NOT ENFORCED"
+ + ")\n"
+ + "FRESHNESS = INTERVAL '30' SECOND\n"
+ + "AS SELECT * FROM t1",
+ "Primary key column 'e' is not defined in the schema at line 2, column 31"),
+ // test primary key with nullable source column
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1 (\n"
+ + " CONSTRAINT ct1 PRIMARY KEY(d) NOT ENFORCED"
+ + ")\n"
+ + "FRESHNESS = INTERVAL '30' SECOND\n"
+ + "AS SELECT * FROM t1",
+ "Invalid primary key 'ct1'. Column 'd' is nullable."));
+ }
+
+ private static List<TestSpec> createWithInvalidPartitions() {
+ return List.of(
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1\n"
+ + "PARTITIONED BY (a, e)\n"
+ + "FRESHNESS = INTERVAL '30' SECOND\n"
+ + "REFRESH_MODE = FULL\n"
+ + "AS SELECT * FROM t1",
+ "Partition column 'e' not defined in the query's schema. Available columns: ['a', 'b', 'c', 'd']."),
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1\n"
+ + "PARTITIONED BY (b, c)\n"
+ + "WITH (\n"
+ + " 'partition.fields.ds.date-formatter' = 'yyyy-MM-dd'\n"
+ + ")\n"
+ + "FRESHNESS = INTERVAL '30' SECOND\n"
+ + "REFRESH_MODE = FULL\n"
+ + "AS SELECT * FROM t3",
+ "Column 'ds' referenced by materialized table option 'partition.fields.ds.date-formatter' isn't a partition column. Available partition columns: ['b', 'c']."),
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1\n"
+ + "WITH (\n"
+ + " 'partition.fields.c.date-formatter' = 'yyyy-MM-dd'\n"
+ + ")\n"
+ + "FRESHNESS = INTERVAL '30' SECOND\n"
+ + "REFRESH_MODE = FULL\n"
+ + "AS SELECT * FROM t3",
+ "Column 'c' referenced by materialized table option 'partition.fields.c.date-formatter' isn't a partition column. Available partition columns: ['']."),
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1\n"
+ + "PARTITIONED BY (b, c)\n"
+ + "WITH (\n"
+ + " 'partition.fields.c.date-formatter' = 'yyyy-MM-dd'\n"
+ + ")\n"
+ + "FRESHNESS = INTERVAL '30' SECOND\n"
+ + "REFRESH_MODE = FULL\n"
+ + "AS SELECT * FROM t3",
+ "Materialized table option 'partition.fields.c.date-formatter' only supports referring to char, varchar and string type partition column. Column `c` type is INT."));
+ }
+
+ private static List<TestSpec> createWithInvalidFreshness() {
+ return List.of(
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1\n"
+ + "FRESHNESS = INTERVAL '40' MINUTE\n"
+ + "REFRESH_MODE = FULL\n"
+ + "AS SELECT * FROM t1",
+ "In full refresh mode, only freshness that are factors of 60 are currently supported when the time unit is MINUTE."),
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1\n"
+ + "FRESHNESS = INTERVAL '40' MINUTE\n"
+ + "AS SELECT * FROM t1",
+ "In full refresh mode, only freshness that are factors of 60 are currently supported when the time unit is MINUTE."),
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1\n"
+ + "FRESHNESS = INTERVAL -'30' SECOND\n"
+ + "REFRESH_MODE = FULL\n"
+ + "AS SELECT * FROM t1",
+ "Materialized table freshness doesn't support negative value."),
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1\n"
+ + "FRESHNESS = INTERVAL '30' YEAR\n"
+ + "AS SELECT * FROM t1",
+ "Materialized table freshness only support SECOND, MINUTE, HOUR, DAY as the time unit."),
+ TestSpec.of(
+ "CREATE MATERIALIZED TABLE mtbl1\n"
+ + "FRESHNESS = INTERVAL '30' DAY TO HOUR\n"
+ + "AS SELECT * FROM t1",
+ "Materialized table freshness only support SECOND, MINUTE, HOUR, DAY as the time unit."));
+ }
+
+ private static Collection<TestSpec> alterSuccessCase() {
+ final Collection<TestSpec> list = new ArrayList<>();
+ list.add(
+ TestSpec.withExpectedSchema(
+ "ALTER MATERIALIZED TABLE base_mtbl ADD (`q` AS current_timestamp AFTER `b`, WATERMARK FOR `q` AS `q` - INTERVAL '1' SECOND)",
+ "(\n"
+ + " `a` BIGINT NOT NULL,\n"
+ + " `b` STRING,\n"
+ + " `q` AS [CURRENT_TIMESTAMP],\n"
+ + " `c` INT,\n"
+ + " `d` STRING,\n"
+ + " WATERMARK FOR `q` AS [`q` - INTERVAL '1' SECOND],\n"
+ + " CONSTRAINT `ct1` PRIMARY KEY (`a`) NOT ENFORCED\n"
+ + ")"));
+ list.add(
+ TestSpec.withExpectedSchema(
+ "ALTER MATERIALIZED TABLE base_mtbl ADD (`q` AS current_timestamp FIRST, `q2` AS current_time FIRST)",
+ "(\n"
+ + " `q2` AS [CURRENT_TIME],\n"
+ + " `q` AS [CURRENT_TIMESTAMP],\n"
+ + " `a` BIGINT NOT NULL,\n"
+ + " `b` STRING,\n"
+ + " `c` INT,\n"
+ + " `d` STRING,\n"
+ + " CONSTRAINT `ct1` PRIMARY KEY (`a`) NOT ENFORCED\n"
+ + ")"));
+ list.add(
+ TestSpec.withExpectedSchema(
+ "ALTER MATERIALIZED TABLE base_mtbl_without_constraint ADD ("
+ + " `c1` AS current_timestamp FIRST, "
+ + " `topic` STRING METADATA VIRTUAL COMMENT 'kafka topic' AFTER `b`, "
+ + " WATERMARK FOR `c1` AS `c1` - INTERVAL '1' SECOND, "
+ + " PRIMARY KEY(`a`) NOT ENFORCED)",
+ "(\n"
+ + " `c1` AS [CURRENT_TIMESTAMP],\n"
+ + " `a` BIGINT NOT NULL,\n"
+ + " `b` STRING,\n"
+ + " `topic` METADATA VIRTUAL COMMENT 'kafka topic',\n"
+ + " `c` INT,\n"
+ + " `d` STRING,\n"
+ + " WATERMARK FOR `c1` AS [`c1` - INTERVAL '1' SECOND],\n"
+ + " CONSTRAINT `PK_a` PRIMARY KEY (`a`) NOT ENFORCED\n"
+ + ")"));
+ return list;
}
private static Collection<Arguments> testDataWithDifferentSchemasSuccessCase() {
@@ -1047,4 +1029,80 @@ class SqlMaterializedTableNodeToOperationConverterTest
"PK_user_id", List.of("user_id")),
List.of())));
}
+
+ /** Boilerplate CatalogMaterializedTable builder for tests. */
+ private CatalogMaterializedTable.Builder getDefaultMaterializedTableBuilder() {
+ return CatalogMaterializedTable.newBuilder()
+ .schema(
+ Schema.newBuilder()
+ .column("a", DataTypes.BIGINT().notNull())
+ .column("b", DataTypes.VARCHAR(Integer.MAX_VALUE))
+ .column("c", DataTypes.INT())
+ .column("d", DataTypes.VARCHAR(Integer.MAX_VALUE))
+ .primaryKeyNamed("ct1", Collections.singletonList("a"))
+ .build())
+ .comment("materialized table comment")
+ .options(Map.of("connector", "filesystem", "format", "json"))
+ .partitionKeys(Arrays.asList("a", "d"))
+ .originalQuery("SELECT *\nFROM `t1`")
+ .expandedQuery(
+ "SELECT `t1`.`a`, `t1`.`b`, `t1`.`c`, `t1`.`d`\n"
+ + "FROM `builtin`.`default`.`t1` AS `t1`");
+ }
+
+ private void createMaterializedTableInCatalog(String sql, String materializedTableName)
+ throws TableAlreadyExistException, DatabaseNotExistException {
+ final ObjectPath objectPath =
+ new ObjectPath(catalogManager.getCurrentDatabase(), materializedTableName);
+ final CreateMaterializedTableOperation operation = createMaterializedTableOperation(sql);
+ catalog.createTable(objectPath, operation.getCatalogMaterializedTable(), true);
+ }
+
+ private ResolvedCatalogMaterializedTable createResolvedCatalogMaterializedTable(String sql) {
+ return createMaterializedTableOperation(sql).getCatalogMaterializedTable();
+ }
+
+ private CreateMaterializedTableOperation createMaterializedTableOperation(String sql) {
+ final Operation operation = parse(sql);
+ assertThat(operation).isInstanceOf(CreateMaterializedTableOperation.class);
+ return (CreateMaterializedTableOperation) operation;
+ }
+
+ private static class TestSpec {
+ private final String sql;
+ private final Class<?> expectedException;
+ private final String errMessage;
+ private final String expectedSchema;
+
+ private TestSpec(String sql, Class<?> expectedException, String errMessage) {
+ this.sql = sql;
+ this.expectedException = expectedException;
+ this.errMessage = errMessage;
+ this.expectedSchema = null;
+ }
+
+ private TestSpec(String sql, String expectedSchema) {
+ this.sql = sql;
+ this.expectedException = null;
+ this.errMessage = null;
+ this.expectedSchema = expectedSchema;
+ }
+
+ public static TestSpec of(String sql, Class<?> expectedException, String errMessage) {
+ return new TestSpec(sql, expectedException, errMessage);
+ }
+
+ public static TestSpec of(String sql, String errMessage) {
+ return of(sql, ValidationException.class, errMessage);
+ }
+
+ public static TestSpec withExpectedSchema(String sql, String expectedSchema) {
+ return new TestSpec(sql, expectedSchema);
+ }
+
+ @Override
+ public String toString() {
+ return sql;
+ }
+ }
}
diff --git a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/api/TableEnvironmentTest.scala b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/api/TableEnvironmentTest.scala
index 27b02c67898..30b36f1f476 100644
--- a/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/api/TableEnvironmentTest.scala
+++ b/flink-table/flink-table-planner/src/test/scala/org/apache/flink/table/api/TableEnvironmentTest.scala
@@ -469,7 +469,7 @@ class TableEnvironmentTest {
|""".stripMargin))
.hasMessageContaining(
"""Failed to execute ALTER TABLE statement.
- |The base table has already defined the primary key constraint [`b`]. You might want to drop it before adding a new one.""".stripMargin)
+ |The current table has already defined the primary key constraint [`b`]. You might want to drop it before adding a new one.""".stripMargin)
.isInstanceOf[ValidationException]
assertThatThrownBy(() => tableEnv.executeSql("""
@@ -477,9 +477,8 @@ class TableEnvironmentTest {
| a STRING
|)
|""".stripMargin))
- .hasMessageContaining(
- """Failed to execute ALTER TABLE statement.
- |Try to add a column `a` which already exists in the table.""".stripMargin)
+ .hasMessageContaining("""Failed to execute ALTER TABLE statement.
+ |Column `a` already exists in the table.""".stripMargin)
.isInstanceOf[ValidationException]
assertThatThrownBy(() => tableEnv.executeSql("""
@@ -544,7 +543,7 @@ class TableEnvironmentTest {
assertThatThrownBy(() => tableEnv.executeSql("ALTER TABLE MyTable ADD WATERMARK FOR ts AS ts"))
.hasMessageContaining(
"""Failed to execute ALTER TABLE statement.
- |The base table has already defined the watermark strategy `d` AS `d` - INTERVAL '2' SECOND. You might want to drop it before adding a new one.""".stripMargin)
+ |The current table has already defined the watermark strategy `d` AS `d` - INTERVAL '2' SECOND. You might want to drop it before adding a new one.""".stripMargin)
.isInstanceOf[ValidationException]
}
@@ -671,9 +670,8 @@ class TableEnvironmentTest {
| x STRING FIRST
|)
|""".stripMargin))
- .hasMessageContaining(
- """Failed to execute ALTER TABLE statement.
- |Try to modify a column `x` which does not exist in the table.""".stripMargin)
+ .hasMessageContaining("""Failed to execute ALTER TABLE statement.
+ |Column `x` does not exist in the table.""".stripMargin)
.isInstanceOf[ValidationException]
assertThatThrownBy(() => tableEnv.executeSql("""
@@ -766,7 +764,7 @@ class TableEnvironmentTest {
|""".stripMargin))
.hasMessageContaining(
"""Failed to execute ALTER TABLE statement.
- |The base table does not define any primary key constraint. You might want to add a new one.""".stripMargin)
+ |The current table does not define any primary key constraint. You might want to add a new one.""".stripMargin)
.isInstanceOf[ValidationException]
tableEnv.executeSql("""
diff --git a/flink-test-utils-parent/flink-table-filesystem-test-utils/src/test/java/org/apache/flink/table/file/testutils/catalog/TestFileSystemCatalogTest.java b/flink-test-utils-parent/flink-table-filesystem-test-utils/src/test/java/org/apache/flink/table/file/testutils/catalog/TestFileSystemCatalogTest.java
index efb0686afb2..9be9499428c 100644
--- a/flink-test-utils-parent/flink-table-filesystem-test-utils/src/test/java/org/apache/flink/table/file/testutils/catalog/TestFileSystemCatalogTest.java
+++ b/flink-test-utils-parent/flink-table-filesystem-test-utils/src/test/java/org/apache/flink/table/file/testutils/catalog/TestFileSystemCatalogTest.java
@@ -24,6 +24,9 @@ import org.apache.flink.table.catalog.CatalogBaseTable;
import org.apache.flink.table.catalog.CatalogDatabase;
import org.apache.flink.table.catalog.CatalogDatabaseImpl;
import org.apache.flink.table.catalog.CatalogMaterializedTable;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.LogicalRefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshMode;
+import org.apache.flink.table.catalog.CatalogMaterializedTable.RefreshStatus;
import org.apache.flink.table.catalog.CatalogTable;
import org.apache.flink.table.catalog.Column;
import org.apache.flink.table.catalog.IntervalFreshness;
@@ -109,13 +112,12 @@ public class TestFileSystemCatalogTest extends TestFileSystemCatalogTestBase {
.originalQuery(DEFAULT_ORIGINAL_QUERY)
.expandedQuery(DEFAULT_EXPANDED_QUERY)
.freshness(FRESHNESS)
- .logicalRefreshMode(
- CatalogMaterializedTable.LogicalRefreshMode.AUTOMATIC)
- .refreshMode(CatalogMaterializedTable.RefreshMode.CONTINUOUS)
- .refreshStatus(CatalogMaterializedTable.RefreshStatus.INITIALIZING)
+ .logicalRefreshMode(LogicalRefreshMode.AUTOMATIC)
+ .refreshMode(RefreshMode.CONTINUOUS)
+ .refreshStatus(RefreshStatus.INITIALIZING)
.build(),
CREATE_RESOLVED_SCHEMA,
- CatalogMaterializedTable.RefreshMode.CONTINUOUS,
+ RefreshMode.CONTINUOUS,
FRESHNESS);
private static final TestRefreshHandler REFRESH_HANDLER =
@@ -247,13 +249,11 @@ public class TestFileSystemCatalogTest extends TestFileSystemCatalogTestBase {
assertThat(actualMaterializedTable.getDefinitionFreshness()).isEqualTo(FRESHNESS);
// validate logical refresh mode
assertThat(actualMaterializedTable.getLogicalRefreshMode())
- .isEqualTo(CatalogMaterializedTable.LogicalRefreshMode.AUTOMATIC);
+ .isSameAs(LogicalRefreshMode.AUTOMATIC);
// validate refresh mode
- assertThat(actualMaterializedTable.getRefreshMode())
- .isEqualTo(CatalogMaterializedTable.RefreshMode.CONTINUOUS);
+ assertThat(actualMaterializedTable.getRefreshMode()).isSameAs(RefreshMode.CONTINUOUS);
// validate refresh status
- assertThat(actualMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.INITIALIZING);
+ assertThat(actualMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.INITIALIZING);
// validate refresh handler
assertThat(actualMaterializedTable.getRefreshHandlerDescription())
.isEqualTo(Optional.empty());
@@ -377,7 +377,7 @@ public class TestFileSystemCatalogTest extends TestFileSystemCatalogTestBase {
// alter materialized table refresh handler
ResolvedCatalogMaterializedTable updatedMaterializedTable =
EXPECTED_CATALOG_MATERIALIZED_TABLE.copy(
- CatalogMaterializedTable.RefreshStatus.ACTIVATED,
+ RefreshStatus.ACTIVATED,
REFRESH_HANDLER.asSummaryString(),
REFRESH_HANDLER.toBytes());
catalog.alterTable(tablePath, updatedMaterializedTable, Collections.emptyList(), false);
@@ -390,8 +390,7 @@ public class TestFileSystemCatalogTest extends TestFileSystemCatalogTestBase {
CatalogMaterializedTable actualMaterializedTable = (CatalogMaterializedTable) actualTable;
// validate refresh status
- assertThat(actualMaterializedTable.getRefreshStatus())
- .isEqualTo(CatalogMaterializedTable.RefreshStatus.ACTIVATED);
+ assertThat(actualMaterializedTable.getRefreshStatus()).isSameAs(RefreshStatus.ACTIVATED);
// validate refresh handler
assertThat(actualMaterializedTable.getRefreshHandlerDescription().get())
.isEqualTo(REFRESH_HANDLER.asSummaryString());