This is an automated email from the ASF dual-hosted git repository.
jooger pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/ignite-3.git
The following commit(s) were added to refs/heads/main by this push:
new ca6af0ac67f IGNITE-25408 Catalog API: createTableAsync does not fetch
the created table in non-default schema (#5888)
ca6af0ac67f is described below
commit ca6af0ac67f519c1aa6b8aa46ce89a4d65ef41f2
Author: Max Zhuravkov <[email protected]>
AuthorDate: Thu May 29 10:52:51 2025 +0300
IGNITE-25408 Catalog API: createTableAsync does not fetch the created table
in non-default schema (#5888)
---
.../java/org/apache/ignite/catalog/ColumnType.java | 2 +-
.../catalog/definitions/TableDefinition.java | 64 ++++---
.../catalog/definitions/TableDefinitionTest.java | 161 +++++++++++++++++
.../ignite/internal/catalog/ItCatalogDslTest.java | 192 ++++++++++++++++++++-
.../catalog/sql/CreateFromAnnotationsImpl.java | 10 +-
.../catalog/sql/CreateFromDefinitionImpl.java | 11 +-
.../internal/catalog/sql/CreateTableImpl.java | 7 +-
.../ignite/internal/catalog/sql/DropTableImpl.java | 7 +-
.../internal/catalog/sql/IgniteCatalogSqlImpl.java | 4 +-
.../apache/ignite/internal/catalog/sql/Name.java | 71 ++++----
.../catalog/sql/TableDefinitionCollector.java | 3 +-
.../ignite/internal/catalog/sql/TableZoneId.java | 7 +-
.../catalog/sql/CreateFromAnnotationsTest.java | 4 +-
.../catalog/sql/CreateFromDefinitionTest.java | 35 +++-
.../internal/catalog/sql/CreateTableTest.java | 75 ++++----
.../ignite/internal/catalog/sql/DropTableTest.java | 18 +-
.../ignite/internal/catalog/sql/QueryPartTest.java | 22 +--
17 files changed, 545 insertions(+), 148 deletions(-)
diff --git
a/modules/api/src/main/java/org/apache/ignite/catalog/ColumnType.java
b/modules/api/src/main/java/org/apache/ignite/catalog/ColumnType.java
index aafb49d8be6..270207390aa 100644
--- a/modules/api/src/main/java/org/apache/ignite/catalog/ColumnType.java
+++ b/modules/api/src/main/java/org/apache/ignite/catalog/ColumnType.java
@@ -178,7 +178,7 @@ public class ColumnType<T> {
public static ColumnType<?> of(Class<?> type) {
ColumnType<?> columnType = TYPES.get(type);
if (columnType == null) {
- throw new UnsupportedOperationException("Class is not supported: "
+ type.getCanonicalName());
+ throw new IllegalArgumentException("Class is not supported: " +
type.getCanonicalName());
}
return columnType.copy();
}
diff --git
a/modules/api/src/main/java/org/apache/ignite/catalog/definitions/TableDefinition.java
b/modules/api/src/main/java/org/apache/ignite/catalog/definitions/TableDefinition.java
index 40e64672bed..464988f2dde 100644
---
a/modules/api/src/main/java/org/apache/ignite/catalog/definitions/TableDefinition.java
+++
b/modules/api/src/main/java/org/apache/ignite/catalog/definitions/TableDefinition.java
@@ -25,16 +25,15 @@ import java.util.stream.Collectors;
import org.apache.ignite.catalog.ColumnSorted;
import org.apache.ignite.catalog.IndexType;
import org.apache.ignite.catalog.SortOrder;
-import org.apache.ignite.catalog.annotations.Table;
+import org.apache.ignite.lang.util.IgniteNameUtils;
+import org.apache.ignite.table.QualifiedName;
import org.jetbrains.annotations.Nullable;
/**
* Definition of the {@code CREATE TABLE} statement.
*/
public class TableDefinition {
- private final String tableName;
-
- private final String schemaName;
+ private final QualifiedName qualifiedName;
private final boolean ifNotExists;
@@ -55,8 +54,7 @@ public class TableDefinition {
private final List<IndexDefinition> indexes;
private TableDefinition(
- String tableName,
- String schemaName,
+ QualifiedName qualifiedName,
boolean ifNotExists,
List<ColumnDefinition> columns,
IndexType pkType,
@@ -67,8 +65,7 @@ public class TableDefinition {
Class<?> valueClass,
List<IndexDefinition> indexes
) {
- this.tableName = tableName;
- this.schemaName = schemaName;
+ this.qualifiedName = qualifiedName;
this.ifNotExists = ifNotExists;
this.columns = columns;
this.pkType = pkType;
@@ -87,16 +84,34 @@ public class TableDefinition {
* @return Builder.
*/
public static Builder builder(String tableName) {
+ Objects.requireNonNull(tableName, "Table name must not be null.");
+ if (tableName.isBlank()) {
+ throw new IllegalArgumentException("Table name must not be
blank.");
+ }
+
return new Builder().tableName(tableName);
}
+ /**
+ * Creates a builder for the table with the specified qualified name.
+ *
+ * @param qualifiedName Qualified name.
+ * @return Builder.
+ */
+ public static Builder builder(QualifiedName qualifiedName) {
+ Objects.requireNonNull(qualifiedName, "Qualified table name must not
be null.");
+ String schemaName =
IgniteNameUtils.quoteIfNeeded(qualifiedName.schemaName());
+ String tableName =
IgniteNameUtils.quoteIfNeeded(qualifiedName.objectName());
+ return new Builder().tableName(tableName).schema(schemaName);
+ }
+
/**
* Returns table name.
*
* @return Table name.
*/
public String tableName() {
- return tableName;
+ return IgniteNameUtils.quoteIfNeeded(qualifiedName.objectName());
}
/**
@@ -105,7 +120,16 @@ public class TableDefinition {
* @return Schema name or {@code null} if not specified.
*/
public @Nullable String schemaName() {
- return schemaName;
+ return IgniteNameUtils.quoteIfNeeded(qualifiedName.schemaName());
+ }
+
+ /**
+ * Returns qualified table name.
+ *
+ * @return Qualified table name.
+ */
+ public QualifiedName qualifiedName() {
+ return qualifiedName;
}
/**
@@ -218,8 +242,7 @@ public class TableDefinition {
}
TableDefinition that = (TableDefinition) o;
return ifNotExists == that.ifNotExists
- && Objects.equals(tableName, that.tableName)
- && Objects.equals(schemaName, that.schemaName)
+ && Objects.equals(qualifiedName, that.qualifiedName)
&& Objects.equals(columns, that.columns)
&& pkType == that.pkType
&& Objects.equals(pkColumns, that.pkColumns)
@@ -233,8 +256,7 @@ public class TableDefinition {
@Override
public int hashCode() {
return Objects.hash(
- tableName,
- schemaName,
+ qualifiedName,
ifNotExists,
columns,
pkType,
@@ -251,9 +273,10 @@ public class TableDefinition {
* Builder for the table definition.
*/
public static class Builder {
+
private String tableName;
- private String schemaName = Table.DEFAULT_SCHEMA;
+ private String schemaName;
private boolean ifNotExists;
@@ -273,11 +296,13 @@ public class TableDefinition {
private final List<IndexDefinition> indexes = new ArrayList<>();
- private Builder() {}
+ private Builder() {
+
+ }
private Builder(TableDefinition definition) {
- tableName = definition.tableName;
- schemaName = definition.schemaName;
+ tableName =
IgniteNameUtils.quoteIfNeeded(definition.qualifiedName.objectName());
+ schemaName =
IgniteNameUtils.quoteIfNeeded(definition.qualifiedName.schemaName());
ifNotExists = definition.ifNotExists;
columns = definition.columns;
pkType = definition.pkType;
@@ -559,8 +584,7 @@ public class TableDefinition {
*/
public TableDefinition build() {
return new TableDefinition(
- tableName,
- schemaName,
+ QualifiedName.of(schemaName, tableName),
ifNotExists,
columns,
pkType,
diff --git
a/modules/api/src/test/java/org/apache/ignite/catalog/definitions/TableDefinitionTest.java
b/modules/api/src/test/java/org/apache/ignite/catalog/definitions/TableDefinitionTest.java
new file mode 100644
index 00000000000..6df41448f59
--- /dev/null
+++
b/modules/api/src/test/java/org/apache/ignite/catalog/definitions/TableDefinitionTest.java
@@ -0,0 +1,161 @@
+/*
+ * 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.ignite.catalog.definitions;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.stream.Stream;
+import org.apache.ignite.lang.util.IgniteNameUtils;
+import org.apache.ignite.table.QualifiedName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Tests for {@link TableDefinition}.
+ */
+public class TableDefinitionTest {
+
+ @Test
+ public void tableNameMustBeNotNull() {
+ var err = assertThrows(NullPointerException.class, () ->
TableDefinition.builder((String) null));
+ assertEquals("Table name must not be null.", err.getMessage());
+ }
+
+ @Test
+ public void qualifiedNameMustBeNotNull() {
+ var err = assertThrows(NullPointerException.class, () ->
TableDefinition.builder((QualifiedName) null));
+ assertEquals("Qualified table name must not be null.",
err.getMessage());
+ }
+
+ @ParameterizedTest
+ @MethodSource("schemaAndTable")
+ public void testFromTableNameThenSetSchema(String schema, String table,
QualifiedName expected) {
+ TableDefinition def = TableDefinition.builder(table)
+ .schema(schema)
+ .build();
+
+ QualifiedName qualifiedName = def.qualifiedName();
+ assertEquals(expected, qualifiedName);
+
assertEquals(IgniteNameUtils.quoteIfNeeded(qualifiedName.schemaName()),
def.schemaName());
+
assertEquals(IgniteNameUtils.quoteIfNeeded(qualifiedName.objectName()),
def.tableName());
+
+ TableDefinition def2 = def.toBuilder().schema(schema).build();
+ assertEquals(def.qualifiedName(), def2.qualifiedName());
+ assertEquals(def.schemaName(), def2.schemaName());
+ assertEquals(def.tableName(), def2.tableName());
+
+ TableDefinition def3 =
TableDefinition.builder(def.qualifiedName()).build();
+ assertEquals(def.qualifiedName(), def3.qualifiedName());
+ assertEquals(def.schemaName(), def3.schemaName());
+ assertEquals(def.tableName(), def3.tableName());
+ }
+
+ @ParameterizedTest
+ @MethodSource("schemaAndTable")
+ public void testFromQualifiedNameThenSchema(String schema, String table,
QualifiedName expected) {
+ QualifiedName initialName = QualifiedName.of("ABC", table);
+ TableDefinition def = TableDefinition.builder(initialName)
+ .schema(schema)
+ .build();
+
+ QualifiedName qualifiedName = def.qualifiedName();
+ assertEquals(expected, qualifiedName);
+
assertEquals(IgniteNameUtils.quoteIfNeeded(qualifiedName.schemaName()),
def.schemaName());
+
assertEquals(IgniteNameUtils.quoteIfNeeded(qualifiedName.objectName()),
def.tableName());
+
+ TableDefinition def2 = def.toBuilder().schema(schema).build();
+ assertEquals(def.qualifiedName(), def2.qualifiedName());
+ assertEquals(def.schemaName(), def2.schemaName());
+ assertEquals(def.tableName(), def2.tableName());
+
+ TableDefinition def3 =
TableDefinition.builder(def.qualifiedName()).build();
+ assertEquals(def.qualifiedName(), def3.qualifiedName());
+ assertEquals(def.schemaName(), def3.schemaName());
+ assertEquals(def.tableName(), def3.tableName());
+ }
+
+ private static Stream<Arguments> schemaAndTable() {
+ return Stream.of(
+ Arguments.of("s", "a", QualifiedName.of("S", "A")),
+ Arguments.of("\"a Schema\"", "a", QualifiedName.of("\"a
Schema\"", "A")),
+ Arguments.of("\"a Schema\"", "\"a table\"",
QualifiedName.of("\"a Schema\"", "\"a table\"")),
+ Arguments.of("\"aSchema\"", "\"aTable\"",
QualifiedName.of("\"aSchema\"", "\"aTable\"")),
+ Arguments.of("\"a Schema\"", "\"atable\"",
QualifiedName.of("\"a Schema\"", "\"atable\"")),
+
+ Arguments.of("\"aSchema\"", "\"aTable \"\"X\"\" \"",
QualifiedName.of("\"aSchema\"", "\"aTable \"\"X\"\" \"")),
+ Arguments.of("\"aSchema\"", "\"\"\"atable\"\"\"",
QualifiedName.of("\"aSchema\"", "\"\"\"atable\"\"\"")),
+ Arguments.of("\"aSchema\"", "\"\"\"aTable\"\"\"",
QualifiedName.of("\"aSchema\"", "\"\"\"aTable\"\"\"")),
+ Arguments.of("\"aSchema\"", "\"\"\"ATABLE\"\"\"",
QualifiedName.of("\"aSchema\"", "\"\"\"ATABLE\"\"\""))
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("overwriteSchemaArgs")
+ public void testFromTableNamePreservesTableNameWithSchemaChanges(String
tableName, QualifiedName expected) {
+ {
+ TableDefinition def = TableDefinition.builder(tableName)
+ .schema("A")
+ .schema("B")
+ .build();
+ assertEquals(expected, def.qualifiedName(), "overwrite once");
+ }
+ {
+ TableDefinition def = TableDefinition.builder(tableName)
+ .schema("X")
+ .schema("A")
+ .schema("B")
+ .build();
+ assertEquals(expected, def.qualifiedName(), "overwrite twice");
+ }
+ }
+
+ @ParameterizedTest
+ @MethodSource("overwriteSchemaArgs")
+ public void fromQualifiedNamePreservesTableNameWithSchemaChanges(String
tableName, QualifiedName expected) {
+ QualifiedName initialName = QualifiedName.of("S", tableName);
+ {
+ TableDefinition def = TableDefinition.builder(initialName)
+ .schema("A")
+ .schema("B")
+ .build();
+ assertEquals(expected, def.qualifiedName(), "overwrite once");
+ }
+ {
+ TableDefinition def = TableDefinition.builder(initialName)
+ .schema("X")
+ .schema("A")
+ .schema("B")
+ .build();
+ assertEquals(expected, def.qualifiedName(), "overwrite twice");
+ }
+ }
+
+ private static Stream<Arguments> overwriteSchemaArgs() {
+ return Stream.of(
+ Arguments.of("A", QualifiedName.of("B", "A")),
+ Arguments.of("Abc", QualifiedName.of("B", "ABC")),
+ Arguments.of("\"Abc\"", QualifiedName.of("B", "\"Abc\"")),
+ Arguments.of("\"abc\"", QualifiedName.of("B", "\"abc\"")),
+ Arguments.of("\"Abc \"\"0\"\" \"", QualifiedName.of("B",
"\"Abc \"\"0\"\" \"")),
+ Arguments.of("\"abc \"\"0\"\" \"", QualifiedName.of("B",
"\"abc \"\"0\"\" \""))
+ );
+ }
+}
diff --git
a/modules/catalog-dsl/src/integrationTest/java/org/apache/ignite/internal/catalog/ItCatalogDslTest.java
b/modules/catalog-dsl/src/integrationTest/java/org/apache/ignite/internal/catalog/ItCatalogDslTest.java
index 56043a1a278..2e6484993f3 100644
---
a/modules/catalog-dsl/src/integrationTest/java/org/apache/ignite/internal/catalog/ItCatalogDslTest.java
+++
b/modules/catalog-dsl/src/integrationTest/java/org/apache/ignite/internal/catalog/ItCatalogDslTest.java
@@ -46,6 +46,7 @@ import org.apache.ignite.catalog.ColumnType;
import org.apache.ignite.catalog.IgniteCatalog;
import org.apache.ignite.catalog.IndexType;
import org.apache.ignite.catalog.SortOrder;
+import org.apache.ignite.catalog.annotations.Id;
import org.apache.ignite.catalog.definitions.ColumnDefinition;
import org.apache.ignite.catalog.definitions.IndexDefinition;
import org.apache.ignite.catalog.definitions.TableDefinition;
@@ -83,9 +84,9 @@ class ItCatalogDslTest extends ClusterPerClassIntegrationTest
{
@AfterEach
void tearDown() {
- sql("DROP TABLE IF EXISTS " + POJO_KV_TABLE_NAME);
- sql("DROP TABLE IF EXISTS " + POJO_RECORD_TABLE_NAME);
- sql("DROP TABLE IF EXISTS " + EXPLICIT_QUOTES_TABLE_NAME);
+ dropAllTables();
+ dropAllSchemas();
+
sql("DROP ZONE IF EXISTS " + ZONE_NAME);
}
@@ -637,9 +638,9 @@ class ItCatalogDslTest extends
ClusterPerClassIntegrationTest {
TableDefinition table = catalog.tableDefinition(name);
assertNotNull(table);
// Table Name
- assertEquals("a b", table.tableName());
+ assertEquals("\"a b\"", table.tableName());
// Schema name
- assertEquals("Table Schema", table.schemaName());
+ assertEquals("\"Table Schema\"", table.schemaName());
// Column
List<ColumnDefinition> columns = table.columns();
@@ -662,7 +663,188 @@ class ItCatalogDslTest extends
ClusterPerClassIntegrationTest {
catalog.dropTable(table);
}
+ @Test
+ public void createDifferentSchemaFromDefinition() {
+ sql("CREATE SCHEMA s");
+
+ {
+ TableDefinition def = TableDefinition.builder(POJO_KV_TABLE_NAME)
+ .columns(column("id", INTEGER), column("fname", VARCHAR),
column("lname", VARCHAR))
+ .primaryKey("id")
+ .build();
+ Table table = catalog().createTable(def);
+ QualifiedName qualifiedName = QualifiedName.of("PUBLIC",
POJO_KV_TABLE_NAME);
+ assertEquals(qualifiedName, table.qualifiedName());
+
+ TableDefinition tableDef =
catalog().tableDefinition(def.qualifiedName());
+ assertEquals(qualifiedName, tableDef.qualifiedName());
+ assertEquals(POJO_KV_TABLE_NAME, tableDef.tableName());
+ assertEquals("PUBLIC", tableDef.schemaName());
+ }
+
+ {
+ TableDefinition def = TableDefinition.builder(POJO_KV_TABLE_NAME)
+ .schema("s")
+ .columns(column("id", INTEGER), column("fname", VARCHAR),
column("lname", VARCHAR))
+ .primaryKey("id")
+ .build();
+
+ Table table = catalog().createTable(def);
+ QualifiedName qualifiedName = QualifiedName.of("S",
POJO_KV_TABLE_NAME);
+ assertEquals(qualifiedName, table.qualifiedName());
+
+ TableDefinition tableDef =
catalog().tableDefinition(def.qualifiedName());
+ assertEquals(qualifiedName, tableDef.qualifiedName());
+ assertEquals(POJO_KV_TABLE_NAME, tableDef.tableName());
+ assertEquals("S", tableDef.schemaName());
+ }
+
+ // Quoted names
+ sql("CREATE SCHEMA \"a Schema\"");
+
+ {
+ TableDefinition def = TableDefinition.builder("A_TABLE")
+ .schema("\"a Schema\"")
+ .columns(column("id", INTEGER), column("fname", VARCHAR),
column("lname", VARCHAR))
+ .primaryKey("id")
+ .build();
+
+ Table table = catalog().createTable(def);
+ QualifiedName qualifiedName = QualifiedName.of("\"a Schema\"",
"A_TABLE");
+ assertEquals(qualifiedName, table.qualifiedName());
+
+ TableDefinition tableDef =
catalog().tableDefinition(def.qualifiedName());
+ assertEquals(qualifiedName, tableDef.qualifiedName());
+ assertEquals("A_TABLE", tableDef.tableName());
+ assertEquals("\"a Schema\"", tableDef.schemaName());
+ }
+
+ {
+ TableDefinition def = TableDefinition.builder("\"a tablE\"")
+ .schema("\"a Schema\"")
+ .columns(column("id", INTEGER), column("fname", VARCHAR),
column("lname", VARCHAR))
+ .primaryKey("id")
+ .build();
+
+ Table table = catalog().createTable(def);
+ QualifiedName qualifiedName = QualifiedName.of("\"a Schema\"",
"\"a tablE\"");
+ assertEquals(qualifiedName, table.qualifiedName());
+
+ TableDefinition tableDef =
catalog().tableDefinition(def.qualifiedName());
+ assertEquals(qualifiedName, tableDef.qualifiedName());
+ assertEquals("\"a tablE\"", tableDef.tableName());
+ assertEquals("\"a Schema\"", tableDef.schemaName());
+ }
+ }
+
+ @Test
+ public void createDifferentSchemaFromAnnotation() {
+ sql("CREATE SCHEMA s");
+
+ {
+ Table table = catalog().createTable(PojoClass1.class);
+ QualifiedName qualifiedName = QualifiedName.of("PUBLIC",
POJO_KV_TABLE_NAME);
+ assertEquals(qualifiedName, table.qualifiedName());
+
+ TableDefinition def = catalog().tableDefinition(qualifiedName);
+ assertEquals(qualifiedName, def.qualifiedName());
+ assertEquals(POJO_KV_TABLE_NAME, def.tableName());
+ assertEquals("PUBLIC", def.schemaName());
+ }
+
+ {
+ Table table = catalog().createTable(PojoClass2.class);
+ QualifiedName qualifiedName = QualifiedName.of("S",
POJO_KV_TABLE_NAME);
+ assertEquals(qualifiedName, table.qualifiedName());
+ assertEquals(qualifiedName,
catalog().tableDefinition(qualifiedName).qualifiedName());
+
+ TableDefinition def = catalog().tableDefinition(qualifiedName);
+ assertEquals(qualifiedName, def.qualifiedName());
+ assertEquals(POJO_KV_TABLE_NAME, def.tableName());
+ assertEquals("S", def.schemaName());
+ }
+
+ // Quoted names
+ sql("CREATE SCHEMA \"a Schema\"");
+
+ {
+ Table table = catalog().createTable(PojoClass3.class);
+ QualifiedName qualifiedName = QualifiedName.of("\"a Schema\"",
"A_TABLE");
+ assertEquals(qualifiedName, table.qualifiedName());
+
+ TableDefinition tableDef =
catalog().tableDefinition(qualifiedName);
+ assertEquals(qualifiedName, tableDef.qualifiedName());
+ assertEquals("A_TABLE", tableDef.tableName());
+ assertEquals("\"a Schema\"", tableDef.schemaName());
+ }
+
+ {
+ Table table = catalog().createTable(PojoClass4.class);
+ QualifiedName qualifiedName = QualifiedName.of("\"a Schema\"",
"\"a tablE\"");
+ assertEquals(qualifiedName, table.qualifiedName());
+ assertEquals(qualifiedName,
catalog().tableDefinition(qualifiedName).qualifiedName());
+
+ TableDefinition tableDef =
catalog().tableDefinition(qualifiedName);
+ assertEquals(qualifiedName, tableDef.qualifiedName());
+ assertEquals("\"a tablE\"", tableDef.tableName());
+ assertEquals("\"a Schema\"", tableDef.schemaName());
+ }
+ }
+
private static IgniteCatalog catalog() {
return CLUSTER.node(0).catalog();
}
+
+ @org.apache.ignite.catalog.annotations.Table(POJO_KV_TABLE_NAME)
+ private static class PojoClass1 {
+ @Id
+ @SuppressWarnings("unused")
+ Integer id;
+ @SuppressWarnings("unused")
+ String fname;
+ @SuppressWarnings("unused")
+ String lname;
+ }
+
+ @org.apache.ignite.catalog.annotations.Table(
+ value = POJO_KV_TABLE_NAME,
+ schemaName = "S"
+ )
+ private static class PojoClass2 {
+ @Id
+ @SuppressWarnings("unused")
+ Integer id;
+ @SuppressWarnings("unused")
+ String fname;
+ @SuppressWarnings("unused")
+ String lname;
+ }
+
+ @org.apache.ignite.catalog.annotations.Table(
+ value = "a_table",
+ schemaName = "\"a Schema\""
+ )
+ private static class PojoClass3 {
+ @Id
+ @SuppressWarnings("unused")
+ Integer id;
+ @SuppressWarnings("unused")
+ String fname;
+ @SuppressWarnings("unused")
+ String lname;
+ }
+
+ @org.apache.ignite.catalog.annotations.Table(
+ value = "\"a tablE\"",
+ schemaName = "\"a Schema\""
+ )
+ private static class PojoClass4 {
+ @Id
+ @SuppressWarnings("unused")
+ Integer id;
+ @SuppressWarnings("unused")
+ String fname;
+ @SuppressWarnings("unused")
+ String lname;
+ }
}
diff --git
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateFromAnnotationsImpl.java
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateFromAnnotationsImpl.java
index 17877abac8f..4617ea3eb2a 100644
---
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateFromAnnotationsImpl.java
+++
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateFromAnnotationsImpl.java
@@ -36,6 +36,7 @@ import org.apache.ignite.catalog.annotations.Index;
import org.apache.ignite.catalog.annotations.Table;
import org.apache.ignite.catalog.annotations.Zone;
import org.apache.ignite.sql.IgniteSql;
+import org.apache.ignite.table.QualifiedName;
class CreateFromAnnotationsImpl extends AbstractCatalogQuery<TableZoneId> {
private CreateZoneImpl createZone;
@@ -44,7 +45,7 @@ class CreateFromAnnotationsImpl extends
AbstractCatalogQuery<TableZoneId> {
private CreateTableImpl createTable;
- private String tableName;
+ private QualifiedName tableName;
private IndexType pkType;
@@ -98,8 +99,11 @@ class CreateFromAnnotationsImpl extends
AbstractCatalogQuery<TableZoneId> {
Table table = clazz.getAnnotation(Table.class);
if (table != null) {
String tableName = table.value().isEmpty() ? clazz.getSimpleName()
: table.value();
- createTable.name(table.schemaName(), tableName);
- this.tableName = tableName;
+ String schemaName = table.schemaName();
+ QualifiedName qualifiedName = QualifiedName.of(schemaName,
tableName);
+
+ this.tableName = qualifiedName;
+ createTable.name(qualifiedName);
processZone(table);
processTable(table);
diff --git
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateFromDefinitionImpl.java
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateFromDefinitionImpl.java
index adc4983ce3b..eecfa7fcf32 100644
---
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateFromDefinitionImpl.java
+++
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateFromDefinitionImpl.java
@@ -32,6 +32,7 @@ import org.apache.ignite.catalog.definitions.TableDefinition;
import org.apache.ignite.catalog.definitions.ZoneDefinition;
import org.apache.ignite.internal.util.StringUtils;
import org.apache.ignite.sql.IgniteSql;
+import org.apache.ignite.table.QualifiedName;
class CreateFromDefinitionImpl extends AbstractCatalogQuery<TableZoneId> {
private CreateZoneImpl createZone;
@@ -40,7 +41,7 @@ class CreateFromDefinitionImpl extends
AbstractCatalogQuery<TableZoneId> {
private CreateTableImpl createTable;
- private String tableName;
+ private QualifiedName tableName;
CreateFromDefinitionImpl(IgniteSql sql) {
super(sql);
@@ -96,9 +97,11 @@ class CreateFromDefinitionImpl extends
AbstractCatalogQuery<TableZoneId> {
CreateFromDefinitionImpl from(TableDefinition def) {
createTable = new CreateTableImpl(sql);
- String tableName = def.tableName();
- this.tableName = tableName;
- createTable.name(def.schemaName(), tableName);
+
+ QualifiedName qualifiedName = def.qualifiedName();
+ this.tableName = qualifiedName;
+ createTable.name(qualifiedName);
+
if (def.ifNotExists()) {
createTable.ifNotExists();
}
diff --git
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateTableImpl.java
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateTableImpl.java
index 826ce3e7aca..87cb8f4d91e 100644
---
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateTableImpl.java
+++
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/CreateTableImpl.java
@@ -29,6 +29,7 @@ import org.apache.ignite.catalog.ColumnType;
import org.apache.ignite.catalog.IndexType;
import org.apache.ignite.catalog.SortOrder;
import org.apache.ignite.sql.IgniteSql;
+import org.apache.ignite.table.QualifiedName;
class CreateTableImpl extends AbstractCatalogQuery<Name> {
private Name tableName;
@@ -59,10 +60,10 @@ class CreateTableImpl extends AbstractCatalogQuery<Name> {
return tableName;
}
- CreateTableImpl name(String... names) {
- Objects.requireNonNull(names, "Table name must not be null.");
+ CreateTableImpl name(QualifiedName name) {
+ Objects.requireNonNull(name, "Table name must not be null.");
- this.tableName = Name.compound(names);
+ this.tableName = Name.qualified(name);
return this;
}
diff --git
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/DropTableImpl.java
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/DropTableImpl.java
index 8dae6e86adf..c924df8fccf 100644
---
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/DropTableImpl.java
+++
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/DropTableImpl.java
@@ -19,6 +19,7 @@ package org.apache.ignite.internal.catalog.sql;
import java.util.Objects;
import org.apache.ignite.sql.IgniteSql;
+import org.apache.ignite.table.QualifiedName;
class DropTableImpl extends AbstractCatalogQuery<Name> {
private Name tableName;
@@ -34,10 +35,10 @@ class DropTableImpl extends AbstractCatalogQuery<Name> {
return tableName;
}
- DropTableImpl name(String... names) {
- Objects.requireNonNull(names, "Table name must not be null");
+ DropTableImpl name(QualifiedName name) {
+ Objects.requireNonNull(name, "Table name must not be null");
- this.tableName = Name.compound(names);
+ this.tableName = Name.qualified(name);
return this;
}
diff --git
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/IgniteCatalogSqlImpl.java
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/IgniteCatalogSqlImpl.java
index d8fb4b6cde5..368b3a5027d 100644
---
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/IgniteCatalogSqlImpl.java
+++
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/IgniteCatalogSqlImpl.java
@@ -156,7 +156,7 @@ public class IgniteCatalogSqlImpl implements IgniteCatalog {
@Override
public CompletableFuture<Void> dropTableAsync(TableDefinition definition) {
return new DropTableImpl(sql)
- .name(definition.schemaName(), definition.tableName())
+ .name(definition.qualifiedName())
.ifExists()
.executeAsync()
.thenApply(unused -> null);
@@ -165,7 +165,7 @@ public class IgniteCatalogSqlImpl implements IgniteCatalog {
@Override
public CompletableFuture<Void> dropTableAsync(QualifiedName name) {
return new DropTableImpl(sql)
- .name(name.schemaName(), name.objectName())
+ .name(name)
.ifExists()
.executeAsync()
.thenApply(unused -> null);
diff --git
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/Name.java
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/Name.java
index f14e34ba6ec..6ea46f9cc54 100644
---
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/Name.java
+++
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/Name.java
@@ -17,10 +17,9 @@
package org.apache.ignite.internal.catalog.sql;
-import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
import org.apache.ignite.lang.util.IgniteNameUtils;
+import org.apache.ignite.table.QualifiedName;
/**
* SQL identifier.
@@ -28,6 +27,8 @@ import org.apache.ignite.lang.util.IgniteNameUtils;
class Name extends QueryPart {
private final List<String> names;
+ private final QualifiedName qualifiedName;
+
/**
* Creates a simple name.
*
@@ -39,35 +40,18 @@ class Name extends QueryPart {
}
/**
- * Creates a compound name (e.g. {@code my_schema.my_table} or {@code
my_table}). Accepts both simple and compound names.
+ * Creates a name from a qualified name.
*
- * @param names Array of names.
+ * @param qualifiedName Qualified name.
* @return Name.
*/
- static Name compound(String... names) {
- List<String> parts = new ArrayList<>(2);
-
- if (names.length == 0) {
- throw new IllegalArgumentException("Names can not be empty");
- } else if (names.length == 1) {
- return new Name(Arrays.asList(names));
- } else {
- boolean canSkipEmpty = true;
- for (String part : names) {
- if (part == null || part.isEmpty()) {
- if (canSkipEmpty) {
- canSkipEmpty = false;
- continue;
- }
- } else {
- // Do not allow non-leading elements to be empty
- canSkipEmpty = false;
- }
- parts.add(part);
- }
+ static Name qualified(QualifiedName qualifiedName) {
+ return new Name(qualifiedName);
+ }
- return new Name(parts);
- }
+ private Name(QualifiedName qualifiedName) {
+ this.qualifiedName = qualifiedName;
+ this.names = null;
}
private Name(List<String> names) {
@@ -76,27 +60,34 @@ class Name extends QueryPart {
throw new IllegalArgumentException("Name parts can not be null
or empty: " + names);
}
}
+ this.qualifiedName = null;
this.names = names;
}
@Override
protected void accept(QueryContext ctx) {
- String separator = "";
- for (String name : names) {
- // If a name is quoted, we must preserve case sensitivity -> write
it as is
- // If a name UPPER(name) is a valid normalized id, then this is a
case insensitive name, write it in uppercase for consistency.
- // Otherwise we must quote it.
- if (name.startsWith("\"")) {
- ctx.sql(separator).sql(name);
- } else {
- String upperCase = name.toUpperCase();
- if (IgniteNameUtils.isValidNormalizedIdentifier(upperCase)) {
- ctx.sql(separator).sql(upperCase);
+ if (qualifiedName != null) {
+ ctx.sql(qualifiedName.toCanonicalForm());
+ } else {
+ assert names != null : "Names must be specified";
+
+ String separator = "";
+ for (String name : names) {
+ // If a name is quoted, we must preserve case sensitivity ->
write it as is
+ // If a name UPPER(name) is a valid normalized id, then this
is a case insensitive name,
+ // write it in uppercase for consistency. Otherwise we must
quote it.
+ if (name.startsWith("\"")) {
+ ctx.sql(separator).sql(name);
} else {
-
ctx.sql(separator).sql(IgniteNameUtils.quoteIfNeeded(name));
+ String upperCase = name.toUpperCase();
+ if
(IgniteNameUtils.isValidNormalizedIdentifier(upperCase)) {
+ ctx.sql(separator).sql(upperCase);
+ } else {
+
ctx.sql(separator).sql(IgniteNameUtils.quoteIfNeeded(name));
+ }
}
+ separator = ".";
}
- separator = ".";
}
}
}
diff --git
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/TableDefinitionCollector.java
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/TableDefinitionCollector.java
index 78bbc900c39..78cc03c75e3 100644
---
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/TableDefinitionCollector.java
+++
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/TableDefinitionCollector.java
@@ -109,8 +109,7 @@ class TableDefinitionCollector {
List<String> colocationColumnList = new
ArrayList<>(colocationColumns.values());
- Builder builder =
TableDefinition.builder(tableName.objectName())
- .schema(tableName.schemaName())
+ Builder builder = TableDefinition.builder(tableName)
.zone(zoneName)
.columns(columns)
.colocateBy(colocationColumnList);
diff --git
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/TableZoneId.java
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/TableZoneId.java
index d4154b20fe6..886224f1def 100644
---
a/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/TableZoneId.java
+++
b/modules/catalog-dsl/src/main/java/org/apache/ignite/internal/catalog/sql/TableZoneId.java
@@ -17,23 +17,24 @@
package org.apache.ignite.internal.catalog.sql;
+import org.apache.ignite.table.QualifiedName;
import org.jetbrains.annotations.Nullable;
/**
* Composite class for table and zone names.
*/
public class TableZoneId {
- private final String tableName;
+ private final QualifiedName tableName;
@Nullable
private final String zoneName;
- public TableZoneId(String tableName, @Nullable String zoneName) {
+ public TableZoneId(QualifiedName tableName, @Nullable String zoneName) {
this.tableName = tableName;
this.zoneName = zoneName;
}
- public String tableName() {
+ public QualifiedName tableName() {
return tableName;
}
diff --git
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateFromAnnotationsTest.java
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateFromAnnotationsTest.java
index 7d84b905478..0fef6f87728 100644
---
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateFromAnnotationsTest.java
+++
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateFromAnnotationsTest.java
@@ -370,8 +370,8 @@ class CreateFromAnnotationsTest {
@SuppressWarnings("unused")
@Table(
- value = "pojo test",
- schemaName = "sche ma",
+ value = "\"pojo test\"",
+ schemaName = "\"sche ma\"",
zone = @Zone(
value = "zone test",
partitions = 1,
diff --git
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateFromDefinitionTest.java
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateFromDefinitionTest.java
index e2023d4ed5c..ba7c013fdc6 100644
---
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateFromDefinitionTest.java
+++
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateFromDefinitionTest.java
@@ -135,9 +135,9 @@ class CreateFromDefinitionTest {
@Test
void createFromTableBuilderQuoteNames() {
- TableDefinition table = TableDefinition.builder("builder test")
+ TableDefinition table = TableDefinition.builder("\"builder test\"")
.ifNotExists()
- .schema("sche ma")
+ .schema("\"sche ma\"")
.colocateBy("id", "id str")
.zone("zone test")
.columns(
@@ -240,6 +240,37 @@ class CreateFromDefinitionTest {
);
}
+ @Test
+ void createFromDefinitionDifferentCase() {
+ String tableName = "Table";
+ String quoted = String.format("\"%s\"", tableName);
+
+ {
+ TableDefinition definition = TableDefinition.builder(quoted)
+ .columns(column("id", INTEGER), column("col1", VARCHAR),
column("col2", VARCHAR))
+ .primaryKey("id")
+ .build();
+
+ assertThat(
+ createTable(definition),
+ is("CREATE TABLE PUBLIC.\"Table\" (ID INT, COL1 VARCHAR,
COL2 VARCHAR, PRIMARY KEY (ID));")
+ );
+ }
+
+ {
+ TableDefinition definition = TableDefinition.builder(quoted)
+ .schema("\"Nice\"")
+ .columns(column("id", INTEGER), column("col1", VARCHAR),
column("col2", VARCHAR))
+ .primaryKey("id")
+ .build();
+
+ assertThat(
+ createTable(definition),
+ is("CREATE TABLE \"Nice\".\"Table\" (ID INT, COL1 VARCHAR,
COL2 VARCHAR, PRIMARY KEY (ID));")
+ );
+ }
+ }
+
@SuppressWarnings("unused")
private static class PojoKey {
@Id
diff --git
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateTableTest.java
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateTableTest.java
index f4ff333f7e4..c3769a3514a 100644
---
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateTableTest.java
+++
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/CreateTableTest.java
@@ -27,104 +27,105 @@ import java.util.List;
import org.apache.ignite.catalog.ColumnSorted;
import org.apache.ignite.catalog.IndexType;
import org.apache.ignite.catalog.SortOrder;
+import org.apache.ignite.table.QualifiedName;
import org.junit.jupiter.api.Test;
class CreateTableTest {
@Test
void ifNotExists() {
- Query query1 =
createTable().ifNotExists().name("table1").addColumn("col1", INTEGER);
+ Query query1 =
createTable().ifNotExists().name(QualifiedName.parse("table1")).addColumn("col1",
INTEGER);
String sql = query1.toString();
- assertThat(sql, is("CREATE TABLE IF NOT EXISTS TABLE1 (COL1 INT);"));
+ assertThat(sql, is("CREATE TABLE IF NOT EXISTS PUBLIC.TABLE1 (COL1
INT);"));
}
@Test
void names() {
- Query query1 = createTable().name("", "table1").addColumn("col1",
INTEGER);
+ Query query1 =
createTable().name(QualifiedName.parse("table1")).addColumn("col1", INTEGER);
String sql = query1.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL1 INT);"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT);"));
- Query query2 = createTable().name(null, "table1").addColumn("col1",
INTEGER);
+ Query query2 =
createTable().name(QualifiedName.parse("public.table1")).addColumn("col1",
INTEGER);
sql = query2.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL1 INT);"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT);"));
- Query query3 = createTable().name("public",
"table1").addColumn("col1", INTEGER);
+ Query query3 = createTable().name(QualifiedName.parse("PUBLIC.\"Tabl
e\"")).addColumn("col1", INTEGER);
sql = query3.toString();
- assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT);"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.\"Tabl e\" (COL1 INT);"));
- Query query4 = createTable().name("public", "Tabl
e").addColumn("col1", INTEGER);
+ Query query4 = createTable().name(QualifiedName.parse("\"PUB
lic\".\"Tabl e\"")).addColumn("col1", INTEGER);
sql = query4.toString();
- assertThat(sql, is("CREATE TABLE PUBLIC.\"Tabl e\" (COL1 INT);"));
+ assertThat(sql, is("CREATE TABLE \"PUB lic\".\"Tabl e\" (COL1 INT);"));
- Query query5 = createTable().name("PUB lic", "Tabl
e").addColumn("col1", INTEGER);
+ Query query5 = createTable().name(QualifiedName.parse("\"PUB
lic\".\"MyTable\"")).addColumn("col1", INTEGER);
sql = query5.toString();
- assertThat(sql, is("CREATE TABLE \"PUB lic\".\"Tabl e\" (COL1 INT);"));
+ assertThat(sql, is("CREATE TABLE \"PUB lic\".\"MyTable\" (COL1
INT);"));
}
@Test
void columns() {
- Query query3 = createTable().name("table1")
+ Query query3 = createTable().name(QualifiedName.fromSimple("table1"))
.addColumn("col", INTEGER);
String sql = query3.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL INT);"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL INT);"));
- Query query2 = createTable().name("table1")
+ Query query2 = createTable().name(QualifiedName.fromSimple("table1"))
.addColumn("col1", INTEGER)
.addColumn("col2", INTEGER);
sql = query2.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL1 INT, COL2 INT);"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT, COL2
INT);"));
}
@Test
void primaryKey() {
- Query query5 = createTable().name("table1")
+ Query query5 = createTable().name(QualifiedName.fromSimple("table1"))
.addColumn("col", INTEGER)
.primaryKey(List.of("col"));
String sql = query5.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL INT, PRIMARY KEY
(COL));"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL INT, PRIMARY KEY
(COL));"));
- Query query4 = createTable().name("table1")
+ Query query4 = createTable().name(QualifiedName.fromSimple("table1"))
.addColumn("col1", INTEGER)
.addColumn("col2", INTEGER)
.primaryKey(List.of("col1", "col2"));
sql = query4.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL1 INT, COL2 INT, PRIMARY
KEY (COL1, COL2));"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT, COL2 INT,
PRIMARY KEY (COL1, COL2));"));
- Query query3 = createTable().name("table1")
+ Query query3 = createTable().name(QualifiedName.fromSimple("table1"))
.addColumn("col1", INTEGER)
.primaryKey(IndexType.SORTED,
List.of(ColumnSorted.column("col1", SortOrder.ASC_NULLS_FIRST)));
sql = query3.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL1 INT, PRIMARY KEY USING
SORTED (COL1 ASC NULLS FIRST));"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT, PRIMARY KEY
USING SORTED (COL1 ASC NULLS FIRST));"));
}
@Test
void colocateBy() {
- Query query5 = createTable().name("table1").addColumn("col1", INTEGER)
+ Query query5 =
createTable().name(QualifiedName.fromSimple("table1")).addColumn("col1",
INTEGER)
.colocateBy("col1");
String sql = query5.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL1 INT) COLOCATE BY
(COL1);"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT) COLOCATE BY
(COL1);"));
- Query query4 = createTable().name("table1").addColumn("col1", INTEGER)
+ Query query4 =
createTable().name(QualifiedName.fromSimple("table1")).addColumn("col1",
INTEGER)
.colocateBy("col1", "col2");
sql = query4.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL1 INT) COLOCATE BY (COL1,
COL2);"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT) COLOCATE BY
(COL1, COL2);"));
- Query query3 = createTable().name("table1").addColumn("col1", INTEGER)
+ Query query3 =
createTable().name(QualifiedName.fromSimple("table1")).addColumn("col1",
INTEGER)
.colocateBy("col1", "col2");
sql = query3.toString();
- assertThat(sql, is("CREATE TABLE TABLE1 (COL1 INT) COLOCATE BY (COL1,
COL2);"));
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT) COLOCATE BY
(COL1, COL2);"));
}
@Test
void withOptions() {
- Query query1 = createTable().name("table1").addColumn("col1", INTEGER)
+ Query query1 =
createTable().name(QualifiedName.fromSimple("table1")).addColumn("col1",
INTEGER)
.zone("zone1");
String sql = query1.toString(); // zone param is lowercase
- assertThat(sql, is("CREATE TABLE TABLE1 (COL1 INT) ZONE ZONE1;")); //
zone result is uppercase
+ assertThat(sql, is("CREATE TABLE PUBLIC.TABLE1 (COL1 INT) ZONE
ZONE1;")); // zone result is uppercase
}
@Test
void index() {
- Query query3 = createTable().name("table1").addColumn("col1", INTEGER)
+ Query query3 =
createTable().name(QualifiedName.fromSimple("table1")).addColumn("col1",
INTEGER)
.addIndex("ix_test1", IndexType.SORTED,
List.of(
ColumnSorted.column("col1"),
@@ -132,17 +133,17 @@ class CreateTableTest {
)
);
String sql = query3.toString();
- assertThat(sql, endsWith("CREATE INDEX IF NOT EXISTS IX_TEST1 ON
TABLE1 USING SORTED (COL1, COL2_UPPER DESC NULLS LAST);"));
+ assertThat(sql, endsWith("CREATE INDEX IF NOT EXISTS IX_TEST1 ON
PUBLIC.TABLE1 USING SORTED (COL1, COL2_UPPER DESC NULLS LAST);"));
- Query query2 = createTable().name("table1").addColumn("col1", INTEGER)
+ Query query2 =
createTable().name(QualifiedName.fromSimple("table1")).addColumn("col1",
INTEGER)
.addIndex("ix_test1", IndexType.HASH,
List.of(ColumnSorted.column("col1")));
sql = query2.toString();
- assertThat(sql, endsWith("CREATE INDEX IF NOT EXISTS IX_TEST1 ON
TABLE1 USING HASH (COL1);"));
+ assertThat(sql, endsWith("CREATE INDEX IF NOT EXISTS IX_TEST1 ON
PUBLIC.TABLE1 USING HASH (COL1);"));
- Query query4 = createTable().name("table1").addColumn("col1", INTEGER)
+ Query query4 =
createTable().name(QualifiedName.fromSimple("table1")).addColumn("col1",
INTEGER)
.addIndex("ix_test1", IndexType.HASH,
List.of(ColumnSorted.column("col1", SortOrder.DEFAULT)));
sql = query4.toString();
- assertThat(sql, endsWith("CREATE INDEX IF NOT EXISTS IX_TEST1 ON
TABLE1 USING HASH (COL1);"));
+ assertThat(sql, endsWith("CREATE INDEX IF NOT EXISTS IX_TEST1 ON
PUBLIC.TABLE1 USING HASH (COL1);"));
SortOrder[] invalidSortOrders = {
SortOrder.DESC,
@@ -158,7 +159,7 @@ class CreateTableTest {
for (SortOrder order : invalidSortOrders) {
assertThrows(
IllegalArgumentException.class,
- () -> createTable().name("table1").addColumn("col1",
INTEGER)
+ () ->
createTable().name(QualifiedName.fromSimple("table1")).addColumn("col1",
INTEGER)
.addIndex("ix_test1", IndexType.HASH,
List.of(ColumnSorted.column("col1", order))),
"Index columns must not define a sort order in hash
indexes."
);
diff --git
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/DropTableTest.java
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/DropTableTest.java
index afea81d4420..951f0d523e4 100644
---
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/DropTableTest.java
+++
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/DropTableTest.java
@@ -20,22 +20,26 @@ package org.apache.ignite.internal.catalog.sql;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
+import org.apache.ignite.table.QualifiedName;
import org.junit.jupiter.api.Test;
class DropTableTest {
@Test
void testDropTable() {
- Query query1 = dropTable().name("table1");
+ Query query1 = dropTable().name(QualifiedName.parse("table1"));
String sql = query1.toString();
- assertThat(sql, is("DROP TABLE TABLE1;"));
+ assertThat(sql, is("DROP TABLE PUBLIC.TABLE1;"));
- Query query2 = dropTable().ifExists().name("table1");
- sql = query2.toString();
- assertThat(sql, is("DROP TABLE IF EXISTS TABLE1;"));
+ Query query2 =
dropTable().ifExists().name(QualifiedName.parse("table1"));
+ assertThat(query2.toString(), is("DROP TABLE IF EXISTS
PUBLIC.TABLE1;"));
- Query query3 = dropTable().ifExists().name("a b");
+ Query query3 = dropTable().ifExists().name(QualifiedName.parse("\"a
b\""));
sql = query3.toString();
- assertThat(sql, is("DROP TABLE IF EXISTS \"a b\";"));
+ assertThat(sql, is("DROP TABLE IF EXISTS PUBLIC.\"a b\";"));
+
+ Query query4 = dropTable().name(QualifiedName.parse("\"MyTable\""));
+ sql = query4.toString();
+ assertThat(sql, is("DROP TABLE PUBLIC.\"MyTable\";"));
}
private static DropTableImpl dropTable() {
diff --git
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/QueryPartTest.java
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/QueryPartTest.java
index 9f74da0517f..e76733987fd 100644
---
a/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/QueryPartTest.java
+++
b/modules/catalog-dsl/src/test/java/org/apache/ignite/internal/catalog/sql/QueryPartTest.java
@@ -41,13 +41,13 @@ import static
org.apache.ignite.internal.catalog.sql.ColumnTypeImpl.wrap;
import static
org.apache.ignite.internal.catalog.sql.IndexColumnImpl.parseColumn;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
-import static org.junit.jupiter.api.Assertions.assertThrows;
import java.math.BigDecimal;
import java.util.List;
import org.apache.ignite.catalog.ColumnType;
import org.apache.ignite.catalog.IndexType;
import org.apache.ignite.catalog.SortOrder;
+import org.apache.ignite.table.QualifiedName;
import org.junit.jupiter.api.Test;
class QueryPartTest {
@@ -78,19 +78,13 @@ class QueryPartTest {
}
@Test
- void compoundNamePart() {
- assertThat(sql(Name.compound("a")), is("A"));
- assertThat(sql(Name.compound("A")), is("A"));
- assertThat(sql(Name.compound(null, "a")), is("A"));
- assertThat(sql(Name.compound("", "a")), is("A"));
- assertThat(sql(Name.compound("a", "b", "c")), is("A.B.C"));
- assertThat(sql(Name.compound("a", "aB Cd")), is("A.\"aB Cd\""));
-
- assertThrows(IllegalArgumentException.class, () -> Name.compound("",
"", "a"));
- assertThrows(IllegalArgumentException.class, () -> Name.compound("a",
""));
- assertThrows(IllegalArgumentException.class, () -> Name.compound("a",
"", "b"));
- assertThrows(IllegalArgumentException.class, () -> Name.compound("a",
null));
- assertThrows(IllegalArgumentException.class, () -> Name.compound("a",
null, "b"));
+ void qualifiedNamePart() {
+ assertThat(sql(Name.qualified(QualifiedName.fromSimple("a"))),
is("PUBLIC.A"));
+ assertThat(sql(Name.qualified(QualifiedName.parse("a.b"))), is("A.B"));
+ assertThat(sql(Name.qualified(QualifiedName.parse("\"Ab\""))),
is("PUBLIC.\"Ab\""));
+ assertThat(sql(Name.qualified(QualifiedName.parse("\"a b\""))),
is("PUBLIC.\"a b\""));
+ assertThat(sql(Name.qualified(QualifiedName.parse("\"a b\".\"c
d\""))), is("\"a b\".\"c d\""));
+ assertThat(sql(Name.qualified(QualifiedName.of("\"a b\"", "\"c
d\""))), is("\"a b\".\"c d\""));
}
@Test
