This is an automated email from the ASF dual-hosted git repository.
amashenkov 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 ed6493a563 IGNITE-20167 Always use version to get SQL schema (#2413)
ed6493a563 is described below
commit ed6493a56390858edac369df2af3bf3da8a14080
Author: Andrew V. Mashenkov <[email protected]>
AuthorDate: Mon Aug 7 18:56:25 2023 +0300
IGNITE-20167 Always use version to get SQL schema (#2413)
---
.../internal/catalog/CatalogManagerImpl.java | 5 ++
.../ignite/internal/catalog/CatalogService.java | 8 ++
.../ignite/internal/sql/api/ItCommonApiTest.java | 13 +--
.../internal/sql/engine/SqlQueryProcessor.java | 10 ++-
.../sql/engine/exec/ExecutionServiceImpl.java | 8 +-
.../internal/sql/engine/prepare/CacheKey.java | 26 +++---
.../sql/engine/prepare/PrepareServiceImpl.java | 3 +-
.../sql/engine/schema/CatalogSqlSchemaManager.java | 94 +++++++++++-----------
.../sql/engine/schema/IgniteSchemaTable.java | 4 +-
.../sql/engine/schema/SqlSchemaManager.java | 20 ++---
.../sql/engine/schema/SqlSchemaManagerImpl.java | 33 ++++----
.../sql/engine/exec/ExecutionServiceImplTest.java | 4 +-
.../sql/engine/exec/MockedStructuresTest.java | 7 ++
.../engine/exec/schema/SqlSchemaManagerTest.java | 37 +++++----
.../engine/framework/PredefinedSchemaManager.java | 34 ++++----
.../internal/sql/engine/framework/TestNode.java | 3 +-
.../engine/schema/CatalogSqlSchemaManagerTest.java | 20 ++---
17 files changed, 170 insertions(+), 159 deletions(-)
diff --git
a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
index 81dd621748..752877429e 100644
---
a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
+++
b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
@@ -282,6 +282,11 @@ public class CatalogManagerImpl extends
Producer<CatalogEvent, CatalogEventParam
return catalogByVer.lastEntry().getKey();
}
+ @Override
+ public CompletableFuture<Void> catalogReadyFuture(int version) {
+ return versionTracker.waitFor(version);
+ }
+
private Catalog catalog(int version) {
return catalogByVer.get(version);
}
diff --git
a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogService.java
b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogService.java
index 66535869ba..26d55827d6 100644
---
a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogService.java
+++
b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogService.java
@@ -18,6 +18,7 @@
package org.apache.ignite.internal.catalog;
import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
import org.apache.ignite.internal.catalog.descriptors.CatalogSchemaDescriptor;
import org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor;
@@ -78,5 +79,12 @@ public interface CatalogService {
*/
int latestCatalogVersion();
+ /**
+ * Returns a future, which completes, when catalog of given version will
be available.
+ *
+ * @param version Catalog version to wait for.
+ */
+ CompletableFuture<Void> catalogReadyFuture(int version);
+
void listen(CatalogEvent evt, EventListener<CatalogEventParameters>
closure);
}
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/api/ItCommonApiTest.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/api/ItCommonApiTest.java
index 5474073978..3fa83733d8 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/api/ItCommonApiTest.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/api/ItCommonApiTest.java
@@ -222,15 +222,16 @@ public class ItCommonApiTest extends
ClusterPerClassIntegrationTest {
}
private static class ErroneousSchemaManager implements SqlSchemaManager {
+
/** {@inheritDoc} */
@Override
- public SchemaPlus schema(@Nullable String schema) {
+ public @Nullable SchemaPlus schema(@Nullable String name, int version)
{
return null;
}
/** {@inheritDoc} */
@Override
- public SchemaPlus schema(@Nullable String name, int version) {
+ public @Nullable SchemaPlus schema(@Nullable String name, long
timestamp) {
return null;
}
@@ -242,13 +243,7 @@ public class ItCommonApiTest extends
ClusterPerClassIntegrationTest {
/** {@inheritDoc} */
@Override
- public CompletableFuture<SchemaPlus> actualSchemaAsync(long ver) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override
- public SchemaPlus activeSchema(@Nullable String name, long timestamp) {
+ public CompletableFuture<Void> schemaReadyFuture(long version) {
throw new UnsupportedOperationException();
}
}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
index 24db718b90..fc133d6c2f 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
@@ -43,6 +43,7 @@ import org.apache.calcite.util.Pair;
import org.apache.ignite.internal.catalog.CatalogManager;
import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.hlc.HybridTimestamp;
import org.apache.ignite.internal.index.IndexManager;
import org.apache.ignite.internal.index.event.IndexEvent;
import org.apache.ignite.internal.index.event.IndexEventParameters;
@@ -443,9 +444,14 @@ public class SqlQueryProcessor implements QueryProcessor {
boolean implicitTxRequired = outerTx == null;
- tx.set(implicitTxRequired ? txManager.begin(!rwOp, null) :
outerTx);
+ InternalTransaction currentTx = implicitTxRequired ?
txManager.begin(!rwOp, null) : outerTx;
- SchemaPlus schema = sqlSchemaManager.schema(schemaName);
+ tx.set(currentTx);
+
+ // TODO IGNITE-18733: wait for actual metadata for TX.
+ HybridTimestamp txTimestamp = currentTx.startTimestamp();
+
+ SchemaPlus schema = sqlSchemaManager.schema(schemaName,
txTimestamp.longValue());
if (schema == null) {
return CompletableFuture.failedFuture(new
SchemaNotFoundException(schemaName));
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionServiceImpl.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionServiceImpl.java
index 6b483f8b0e..420a5f11be 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionServiceImpl.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionServiceImpl.java
@@ -239,13 +239,13 @@ public class ExecutionServiceImpl<RowT> implements
ExecutionService, TopologyEve
return queryManager.execute(tx, plan);
}
- private BaseQueryContext createQueryContext(UUID queryId, @Nullable String
schema, Object[] params) {
+ private BaseQueryContext createQueryContext(UUID queryId, long
schemaVersion, @Nullable String schema, Object[] params) {
return BaseQueryContext.builder()
.queryId(queryId)
.parameters(params)
.frameworkConfig(
Frameworks.newConfigBuilder(FRAMEWORK_CONFIG)
- .defaultSchema(sqlSchemaManager.schema(schema))
+ .defaultSchema(sqlSchemaManager.schema(schema,
(int) schemaVersion))
.build()
)
.logger(LOG)
@@ -330,7 +330,7 @@ public class ExecutionServiceImpl<RowT> implements
ExecutionService, TopologyEve
private void onMessage(String nodeName, QueryStartRequest msg) {
assert nodeName != null && msg != null;
- CompletableFuture<?> fut =
sqlSchemaManager.actualSchemaAsync(msg.schemaVersion());
+ CompletableFuture<Void> fut =
sqlSchemaManager.schemaReadyFuture(msg.schemaVersion());
if (fut.isDone()) {
submitFragment(nodeName, msg);
@@ -427,7 +427,7 @@ public class ExecutionServiceImpl<RowT> implements
ExecutionService, TopologyEve
private DistributedQueryManager getOrCreateQueryManager(QueryStartRequest
msg) {
return queryManagerMap.computeIfAbsent(msg.queryId(), key -> {
- BaseQueryContext ctx = createQueryContext(key, msg.schema(),
msg.parameters());
+ BaseQueryContext ctx = createQueryContext(key,
msg.schemaVersion(), msg.schema(), msg.parameters());
return new DistributedQueryManager(ctx);
});
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/CacheKey.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/CacheKey.java
index 89cd57d3a2..ae84daaf49 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/CacheKey.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/CacheKey.java
@@ -26,7 +26,9 @@ import java.util.Objects;
* context could be schema name, dynamic parameters, and so on...
*/
public class CacheKey {
- public static final Class[] EMPTY_CLASS_ARRAY = {};
+ static final Class<?>[] EMPTY_CLASS_ARRAY = {};
+
+ private final long catalogVersion;
private final String schemaName;
@@ -34,34 +36,26 @@ public class CacheKey {
private final Object contextKey;
- private final Class[] paramTypes;
+ private final Class<?>[] paramTypes;
/**
* Constructor.
*
+ * @param catalogVersion Catalog version.
* @param schemaName Schema name.
* @param query Query string.
* @param contextKey Optional context key to differ queries with and
without/different flags, having an impact on result plan (like
* LOCAL flag)
* @param paramTypes Types of all dynamic parameters, no any type can be
{@code null}.
*/
- public CacheKey(String schemaName, String query, Object contextKey,
Class[] paramTypes) {
+ public CacheKey(long catalogVersion, String schemaName, String query,
Object contextKey, Class<?>[] paramTypes) {
+ this.catalogVersion = catalogVersion;
this.schemaName = schemaName;
this.query = query;
this.contextKey = contextKey;
this.paramTypes = paramTypes;
}
- /**
- * Constructor.
- *
- * @param schemaName Schema name.
- * @param query Query string.
- */
- public CacheKey(String schemaName, String query) {
- this(schemaName, query, null, EMPTY_CLASS_ARRAY);
- }
-
/** {@inheritDoc} */
@Override
public boolean equals(Object o) {
@@ -74,6 +68,9 @@ public class CacheKey {
CacheKey cacheKey = (CacheKey) o;
+ if (catalogVersion != cacheKey.catalogVersion) {
+ return false;
+ }
if (!schemaName.equals(cacheKey.schemaName)) {
return false;
}
@@ -89,7 +86,8 @@ public class CacheKey {
@Override
public int hashCode() {
- int result = schemaName.hashCode();
+ int result = Long.hashCode(catalogVersion);
+ result = 31 * result + schemaName.hashCode();
result = 31 * result + query.hashCode();
result = 31 * result + (contextKey != null ? contextKey.hashCode() :
0);
result = 31 * result + Arrays.deepHashCode(paramTypes);
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/PrepareServiceImpl.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/PrepareServiceImpl.java
index ae7f38842e..81b58c958f 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/PrepareServiceImpl.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/PrepareServiceImpl.java
@@ -310,12 +310,13 @@ public class PrepareServiceImpl implements
PrepareService, SchemaUpdateListener
private static CacheKey createCacheKey(ParsedResult parsedResult,
PlanningContext ctx) {
boolean distributed = distributionPresent(ctx.config().getTraitDefs());
+ long catalogVersion =
ctx.unwrap(BaseQueryContext.class).schemaVersion();
Class[] paramTypes = ctx.parameters().length == 0
? EMPTY_CLASS_ARRAY :
Arrays.stream(ctx.parameters()).map(p -> (p != null) ?
p.getClass() : Void.class).toArray(Class[]::new);
- return new CacheKey(ctx.schemaName(), parsedResult.normalizedQuery(),
distributed, paramTypes);
+ return new CacheKey(catalogVersion, ctx.schemaName(),
parsedResult.normalizedQuery(), distributed, paramTypes);
}
private ResultSetMetadata resultSetMetadata(
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManager.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManager.java
index ed27b83e91..79c3023d75 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManager.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManager.java
@@ -20,6 +20,8 @@ package org.apache.ignite.internal.sql.engine.schema;
import static
org.apache.ignite.internal.catalog.CatalogService.DEFAULT_SCHEMA_NAME;
import com.github.benmanes.caffeine.cache.Caffeine;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
@@ -69,17 +71,21 @@ public class CatalogSqlSchemaManager implements
SqlSchemaManager {
/** {@inheritDoc} */
@Override
- public SchemaPlus schema(@Nullable String schema) {
- // Should be removed -schema(name, version) must be used instead
- throw new UnsupportedOperationException();
+ public SchemaPlus schema(@Nullable String name, int version) {
+ String schemaName = name == null ? DEFAULT_SCHEMA_NAME : name;
+
+ Entry<String, Integer> entry = Map.entry(schemaName, version);
+ return cache.computeIfAbsent(entry, (e) ->
createSqlSchema(e.getValue(), catalogManager.schema(e.getKey(), e.getValue())));
}
/** {@inheritDoc} */
@Override
- public SchemaPlus schema(String name, int version) {
+ public SchemaPlus schema(@Nullable String name, long timestamp) {
String schemaName = name == null ? DEFAULT_SCHEMA_NAME : name;
- Entry<String, Integer> entry = Map.entry(schemaName, version);
+ int schemaVersion = catalogManager.activeCatalogVersion(timestamp);
+
+ Entry<String, Integer> entry = Map.entry(schemaName, schemaVersion);
return cache.computeIfAbsent(entry, (e) ->
createSqlSchema(e.getValue(), catalogManager.schema(e.getKey(), e.getValue())));
}
@@ -92,74 +98,52 @@ public class CatalogSqlSchemaManager implements
SqlSchemaManager {
/** {@inheritDoc} */
@Override
- public CompletableFuture<?> actualSchemaAsync(long ver) {
- return CompletableFuture.completedFuture(catalogManager.schema((int)
ver));
+ public CompletableFuture<Void> schemaReadyFuture(long version) {
+ // SqlSchemaManager creates SQL schema lazily on-demand, thus waiting
for Catalog version is enough.
+ return catalogManager.catalogReadyFuture((int) version);
}
- /** {@inheritDoc} */
- @Override
- public SchemaPlus activeSchema(@Nullable String name, long timestamp) {
- String schemaName = name == null ? DEFAULT_SCHEMA_NAME : name;
-
- int version = catalogManager.activeCatalogVersion(timestamp);
-
- CatalogSchemaDescriptor descriptor = catalogManager.schema(schemaName,
version);
+ private static SchemaPlus createSqlSchema(int version,
CatalogSchemaDescriptor schemaDescriptor) {
+ String schemaName = schemaDescriptor.name();
- Entry<String, Integer> entry = Map.entry(schemaName, version);
- return cache.computeIfAbsent(entry, (v) ->
createSqlSchema(v.getValue(), descriptor));
- }
-
- private SchemaPlus createSqlSchema(int version, CatalogSchemaDescriptor
descriptor) {
- String schemaName = descriptor.name();
-
- int numTables = descriptor.tables().length;
+ int numTables = schemaDescriptor.tables().length;
Map<String, Table> schemaTables = new HashMap<>(numTables);
- Map<Integer, TableDescriptorImpl> tableDescriptorMap = new
LinkedHashMap<>(numTables);
+ Int2ObjectMap<TableDescriptor> tableDescriptorMap = new
Int2ObjectOpenHashMap<>(numTables);
// Assemble sql-engine.TableDescriptors as they are required by
indexes.
- for (CatalogTableDescriptor tableDescriptor : descriptor.tables()) {
- TableDescriptorImpl descriptorImpl =
createTableDescriptor(tableDescriptor);
- tableDescriptorMap.put(tableDescriptor.id(), descriptorImpl);
+ for (CatalogTableDescriptor tableDescriptor :
schemaDescriptor.tables()) {
+ TableDescriptor descriptor =
createTableDescriptor(tableDescriptor);
+ tableDescriptorMap.put(tableDescriptor.id(), descriptor);
}
- Map<Integer, Map<String, IgniteSchemaIndex>> schemaTableIndexes = new
HashMap<>(descriptor.indexes().length);
+ Int2ObjectMap<Map<String, IgniteSchemaIndex>> schemaTableIndexes = new
Int2ObjectOpenHashMap<>(schemaDescriptor.indexes().length);
// Assemble indexes as they are required by tables.
- for (CatalogIndexDescriptor indexDescriptor : descriptor.indexes()) {
+ for (CatalogIndexDescriptor indexDescriptor :
schemaDescriptor.indexes()) {
int tableId = indexDescriptor.tableId();
- TableDescriptorImpl tableDescriptorImpl =
tableDescriptorMap.get(tableId);
- assert tableDescriptorImpl != null : "Table is not found in
schema: " + tableId;
+ TableDescriptor tableDescriptor = tableDescriptorMap.get(tableId);
+ assert tableDescriptor != null : "Table is not found in schema: "
+ tableId;
String indexName = indexDescriptor.name();
Map<String, IgniteSchemaIndex> tableIndexes =
schemaTableIndexes.computeIfAbsent(tableId, id -> new LinkedHashMap<>());
- Type type;
- if (indexDescriptor instanceof CatalogSortedIndexDescriptor) {
- type = Type.SORTED;
- } else if (indexDescriptor instanceof CatalogHashIndexDescriptor) {
- type = Type.HASH;
- } else {
- throw new IllegalArgumentException("Unexpected index type: " +
indexDescriptor);
- }
-
- RelCollation indexCollation =
IgniteSchemaIndex.createIndexCollation(indexDescriptor, tableDescriptorImpl);
- IgniteSchemaIndex schemaIndex = new IgniteSchemaIndex(indexName,
type, tableDescriptorImpl.distribution(), indexCollation);
+ IgniteSchemaIndex schemaIndex = createSchemaIndex(indexDescriptor,
tableDescriptor);
tableIndexes.put(indexName, schemaIndex);
schemaTableIndexes.put(tableId, tableIndexes);
}
// Assemble tables.
- for (CatalogTableDescriptor tableDescriptor : descriptor.tables()) {
+ for (CatalogTableDescriptor tableDescriptor :
schemaDescriptor.tables()) {
int tableId = tableDescriptor.id();
String tableName = tableDescriptor.name();
- TableDescriptorImpl descriptorImpl =
tableDescriptorMap.get(tableId);
- assert descriptorImpl != null;
+ TableDescriptor descriptor = tableDescriptorMap.get(tableId);
+ assert descriptor != null;
- IgniteStatistic statistic = new IgniteStatistic(() -> 0.0d,
descriptorImpl.distribution());
+ IgniteStatistic statistic = new IgniteStatistic(() -> 0.0d,
descriptor.distribution());
Map<String, IgniteSchemaIndex> tableIndexMap =
schemaTableIndexes.getOrDefault(tableId, Collections.emptyMap());
- IgniteSchemaTable schemaTable = new IgniteSchemaTable(tableName,
tableId, version, descriptorImpl, statistic, tableIndexMap);
+ IgniteSchemaTable schemaTable = new IgniteSchemaTable(tableName,
tableId, version, descriptor, statistic, tableIndexMap);
schemaTables.put(tableName, schemaTable);
}
@@ -170,7 +154,21 @@ public class CatalogSqlSchemaManager implements
SqlSchemaManager {
return rootSchema.add(schemaName, igniteSchema);
}
- private static TableDescriptorImpl
createTableDescriptor(CatalogTableDescriptor descriptor) {
+ private static IgniteSchemaIndex createSchemaIndex(CatalogIndexDescriptor
indexDescriptor, TableDescriptor tableDescriptor) {
+ Type type;
+ if (indexDescriptor instanceof CatalogSortedIndexDescriptor) {
+ type = Type.SORTED;
+ } else if (indexDescriptor instanceof CatalogHashIndexDescriptor) {
+ type = Type.HASH;
+ } else {
+ throw new IllegalArgumentException("Unexpected index type: " +
indexDescriptor);
+ }
+
+ RelCollation indexCollation =
IgniteSchemaIndex.createIndexCollation(indexDescriptor, tableDescriptor);
+ return new IgniteSchemaIndex(indexDescriptor.name(), type,
tableDescriptor.distribution(), indexCollation);
+ }
+
+ private static TableDescriptor
createTableDescriptor(CatalogTableDescriptor descriptor) {
List<ColumnDescriptor> colDescriptors = new ArrayList<>();
List<Integer> colocationColumns = new ArrayList<>();
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchemaTable.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchemaTable.java
index b27768ddca..74cee2f891 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchemaTable.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchemaTable.java
@@ -187,8 +187,8 @@ public final class IgniteSchemaTable extends AbstractTable
implements IgniteTabl
/** {@inheritDoc} */
@Override
public <C> @Nullable C unwrap(Class<C> cls) {
- if (cls.isInstance(this)) {
- return cls.cast(this);
+ if (cls.isInstance(desc)) {
+ return cls.cast(desc);
}
return super.unwrap(cls);
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManager.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManager.java
index ef45bc8598..beed01fe86 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManager.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManager.java
@@ -26,31 +26,27 @@ import org.jetbrains.annotations.Nullable;
*/
public interface SqlSchemaManager {
/**
- * Returns a required schema if specified, or default schema otherwise.
+ * Returns schema with given name and by the given version, if name is not
specified, returns default schema of the given version.
*/
- SchemaPlus schema(@Nullable String schema);
+ SchemaPlus schema(@Nullable String name, int version);
/**
- * Returns schema with given name and by the given version, if name is not
specified, returns default schema of the given version.
+ * Returns schema with given name and by the given timestamp, if name is
not specified, returns default schema of the given version.
*/
- SchemaPlus schema(@Nullable String name, int version);
+ SchemaPlus schema(@Nullable String name, long timestamp);
/**
* Returns a table by given id.
*
* @param id An id of required table.
- *
* @return The table.
*/
IgniteTable tableById(int id);
/**
- * Wait for {@code ver} schema version, just a stub, need to be removed
after IGNITE-18733.
- */
- CompletableFuture<?> actualSchemaAsync(long ver);
-
- /**
- * Returns a required schema if specified, or default schema otherwise.
+ * Returns a future to wait for given SQL schema version readiness.
+ *
+ * @param version SQL schema version to wait.
*/
- SchemaPlus activeSchema(@Nullable String name, long timestamp);
+ CompletableFuture<Void> schemaReadyFuture(long version);
}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManagerImpl.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManagerImpl.java
index 1722d86074..c2ec8e2300 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManagerImpl.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManagerImpl.java
@@ -64,6 +64,7 @@ import org.apache.ignite.internal.util.IgniteSpinBusyLock;
import org.apache.ignite.lang.IgniteInternalException;
import org.apache.ignite.lang.NodeStoppingException;
import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
/**
* Holds actual schema and mutates it on schema change, requested by Ignite.
@@ -139,9 +140,9 @@ public class SqlSchemaManagerImpl implements
SqlSchemaManager {
});
}
- /** {@inheritDoc} */
- @Override
- public SchemaPlus schema(@Nullable String schema) {
+ /** Returns latest schema. */
+ @TestOnly
+ public SchemaPlus latestSchema(@Nullable String schema) {
// stub for waiting pk indexes, more clear place is IgniteSchema
CompletableFuture.allOf(pkIdxReady.values().toArray(CompletableFuture[]::new)).join();
@@ -152,25 +153,31 @@ public class SqlSchemaManagerImpl implements
SqlSchemaManager {
/** {@inheritDoc} */
@Override
- public SchemaPlus schema(String name, int version) {
- throw new UnsupportedOperationException();
+ public SchemaPlus schema(@Nullable String name, int version) {
+ return latestSchema(name);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public SchemaPlus schema(@Nullable String name, long timestamp) {
+ return latestSchema(name);
}
/** {@inheritDoc} */
@Override
- public CompletableFuture<?> actualSchemaAsync(long ver) {
+ public CompletableFuture<Void> schemaReadyFuture(long version) {
if (!busyLock.enterBusy()) {
throw new IgniteInternalException(NODE_STOPPING_ERR, new
NodeStoppingException());
}
try {
- if (ver == IgniteSchema.INITIAL_VERSION) {
- return completedFuture(calciteSchemaVv.latest());
+ if (version == IgniteSchema.INITIAL_VERSION) {
+ return completedFuture(null);
}
- CompletableFuture<SchemaPlus> lastSchemaFut;
+ CompletableFuture<Void> lastSchemaFut;
try {
- lastSchemaFut = calciteSchemaVv.get(ver);
+ lastSchemaFut = calciteSchemaVv.get(version).thenAccept(ignore
-> {});
} catch (OutdatedTokenException e) {
return completedFuture(null);
}
@@ -181,12 +188,6 @@ public class SqlSchemaManagerImpl implements
SqlSchemaManager {
}
}
- /** {@inheritDoc} */
- @Override
- public SchemaPlus activeSchema(@Nullable String name, long timestamp) {
- throw new UnsupportedOperationException();
- }
-
/** {@inheritDoc} */
@Override
public IgniteTable tableById(int id) {
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionServiceImplTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionServiceImplTest.java
index 103e7077b8..4a5a0a6a1c 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionServiceImplTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionServiceImplTest.java
@@ -594,7 +594,7 @@ public class ExecutionServiceImplTest {
when(schemaManagerMock.tableById(anyInt())).thenReturn(table);
-
when(schemaManagerMock.actualSchemaAsync(isA(long.class))).thenReturn(CompletableFuture.completedFuture(null));
+
when(schemaManagerMock.schemaReadyFuture(isA(long.class))).thenReturn(CompletableFuture.completedFuture(null));
TestExecutableTableRegistry executableTableRegistry = new
TestExecutableTableRegistry();
executableTableRegistry.setColocatioGroupProvider((tableId) -> {
@@ -612,7 +612,7 @@ public class ExecutionServiceImplTest {
rootSch.add(schema.getName(), schema);
SchemaPlus plus = rootSch.plus().getSubSchema(schema.getName());
- when(schemaManagerMock.schema(any())).thenReturn(plus);
+ when(schemaManagerMock.schema(any(), anyInt())).thenReturn(plus);
var executionService = new ExecutionServiceImpl<>(
messageService,
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/MockedStructuresTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/MockedStructuresTest.java
index 294e66ab2a..775154da8e 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/MockedStructuresTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/MockedStructuresTest.java
@@ -30,6 +30,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.mock;
@@ -58,6 +59,7 @@ import
org.apache.ignite.internal.distributionzones.DistributionZoneManager;
import
org.apache.ignite.internal.distributionzones.DistributionZoneNotFoundException;
import
org.apache.ignite.internal.distributionzones.configuration.DistributionZonesConfiguration;
import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.hlc.HybridTimestamp;
import org.apache.ignite.internal.index.IndexManager;
import org.apache.ignite.internal.metastorage.MetaStorageManager;
import org.apache.ignite.internal.metastorage.dsl.Operation;
@@ -95,6 +97,7 @@ import
org.apache.ignite.internal.table.distributed.TableManager;
import
org.apache.ignite.internal.table.distributed.raft.snapshot.outgoing.OutgoingSnapshotsManager;
import org.apache.ignite.internal.testframework.IgniteAbstractTest;
import org.apache.ignite.internal.testframework.IgniteTestUtils;
+import org.apache.ignite.internal.tx.InternalTransaction;
import org.apache.ignite.internal.tx.TxManager;
import org.apache.ignite.internal.vault.VaultManager;
import org.apache.ignite.lang.ByteArray;
@@ -579,6 +582,10 @@ public class MockedStructuresTest extends
IgniteAbstractTest {
return ret;
});
+ InternalTransaction tx = mock(InternalTransaction.class);
+ when(tx.startTimestamp()).thenReturn(HybridTimestamp.MAX_VALUE);
+ when(tm.begin(anyBoolean(), any())).thenReturn(tx);
+
when(replicaManager.stopReplica(any())).thenReturn(completedFuture(true));
return createTableManager();
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/schema/SqlSchemaManagerTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/schema/SqlSchemaManagerTest.java
index eb63c18ebe..c74ab32423 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/schema/SqlSchemaManagerTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/schema/SqlSchemaManagerTest.java
@@ -40,7 +40,7 @@ import java.util.function.Consumer;
import java.util.function.LongFunction;
import org.apache.calcite.schema.SchemaPlus;
import org.apache.calcite.schema.Table;
-import org.apache.ignite.internal.index.Index;
+import org.apache.ignite.internal.catalog.CatalogService;
import org.apache.ignite.internal.index.IndexDescriptor;
import org.apache.ignite.internal.schema.Column;
import org.apache.ignite.internal.schema.NativeTypes;
@@ -70,6 +70,8 @@ import org.mockito.junit.jupiter.MockitoExtension;
*/
@ExtendWith(MockitoExtension.class)
public class SqlSchemaManagerTest extends BaseIgniteAbstractTest {
+ private static final String SCHEMA_NAME =
CatalogService.DEFAULT_SCHEMA_NAME;
+
private final int tableId = 1;
private final int indexId = 2;
@@ -89,9 +91,6 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
@Mock
private TableImpl table;
- @Mock
- private Index<IndexDescriptor> index;
-
@Mock
private SchemaRegistryImpl schemaRegistry;
@@ -133,7 +132,7 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
when(schemaManager.schemaRegistry(anyLong(),
anyInt())).thenReturn(completedFuture(schemaRegistry));
- sqlSchemaManager.onTableCreated("PUBLIC", tableId,
testRevisionRegister.actualToken() + 1);
+ sqlSchemaManager.onTableCreated(SCHEMA_NAME, tableId,
testRevisionRegister.actualToken() + 1);
testRevisionRegister.moveForward();
TestHashIndex testHashIndex = TestHashIndex.create(List.of("ID"),
"pk_idx", tableId);
@@ -147,16 +146,16 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
testRevisionRegister.moveForward();
- Table schemaTable = sqlSchemaManager.schema("PUBLIC").getTable("T");
+ Table schemaTable =
sqlSchemaManager.latestSchema(SCHEMA_NAME).getTable("T");
assertNotNull(schemaTable);
IgniteTableImpl igniteTable = assertInstanceOf(IgniteTableImpl.class,
schemaTable);
assertEquals(tableId, igniteTable.id());
- sqlSchemaManager.onTableDropped("PUBLIC", tableId,
testRevisionRegister.actualToken() + 1);
+ sqlSchemaManager.onTableDropped(SCHEMA_NAME, tableId,
testRevisionRegister.actualToken() + 1);
testRevisionRegister.moveForward();
- assertNull(sqlSchemaManager.schema("PUBLIC").getTable("T"));
+ assertNull(sqlSchemaManager.latestSchema(SCHEMA_NAME).getTable("T"));
}
@Test
@@ -171,7 +170,7 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
when(schemaRegistry.lastSchemaVersion()).thenReturn(schemaDescriptor.version());
when(schemaManager.schemaRegistry(anyLong(),
anyInt())).thenReturn(completedFuture(schemaRegistry));
- sqlSchemaManager.onTableCreated("PUBLIC", tableId,
testRevisionRegister.actualToken() + 1);
+ sqlSchemaManager.onTableCreated(SCHEMA_NAME, tableId,
testRevisionRegister.actualToken() + 1);
testRevisionRegister.moveForward();
TestHashIndex testHashIndex = TestHashIndex.create(List.of("ID"),
"pk_idx", tableId);
@@ -185,7 +184,7 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
testRevisionRegister.moveForward();
- assertEquals(1, ((IgniteTableImpl)
sqlSchemaManager.schema("PUBLIC").getTable("T")).indexes().size());
+ assertEquals(1, ((IgniteTableImpl)
sqlSchemaManager.latestSchema(SCHEMA_NAME).getTable("T")).indexes().size());
IndexDescriptor descMock = mock(IndexDescriptor.class);
when(descMock.columns()).thenReturn(List.of());
@@ -195,7 +194,7 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
testRevisionRegister.moveForward();
- IgniteSchema schema =
sqlSchemaManager.schema("PUBLIC").unwrap(IgniteSchema.class);
+ IgniteSchema schema =
sqlSchemaManager.latestSchema(SCHEMA_NAME).unwrap(IgniteSchema.class);
Table schemaTable = schema.getTable("T");
IgniteIndex igniteIndex = schema.index(indexId);
@@ -206,10 +205,10 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
assertEquals(igniteTable.id(), igniteIndex.tableId());
assertSame(igniteIndex, igniteTable.indexes().get("PUBLIC.I"));
- sqlSchemaManager.onIndexDropped("PUBLIC", igniteTable.id(), indexId,
testRevisionRegister.actualToken() + 1);
+ sqlSchemaManager.onIndexDropped(SCHEMA_NAME, igniteTable.id(),
indexId, testRevisionRegister.actualToken() + 1);
testRevisionRegister.moveForward();
-
assertNull(sqlSchemaManager.schema("PUBLIC").unwrap(IgniteSchema.class).index(indexId));
+
assertNull(sqlSchemaManager.latestSchema(SCHEMA_NAME).unwrap(IgniteSchema.class).index(indexId));
verifyNoMoreInteractions(tableManager);
}
@@ -227,7 +226,7 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
when(schemaRegistry.lastSchemaVersion()).thenReturn(schemaDescriptor.version());
when(schemaManager.schemaRegistry(anyLong(),
anyInt())).thenReturn(completedFuture(schemaRegistry));
- sqlSchemaManager.onTableCreated("PUBLIC", table.tableId(),
testRevisionRegister.actualToken() + 1);
+ sqlSchemaManager.onTableCreated(SCHEMA_NAME, table.tableId(),
testRevisionRegister.actualToken() + 1);
testRevisionRegister.moveForward();
TestHashIndex testHashIndex = TestHashIndex.create(List.of("ID"),
"pk_idx", tableId);
@@ -248,12 +247,12 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
when(descMock.name()).thenReturn(idxName);
{
- SchemaPlus schema1 = sqlSchemaManager.schema("PUBLIC");
+ SchemaPlus schema1 = sqlSchemaManager.latestSchema(SCHEMA_NAME);
sqlSchemaManager.onIndexCreated(tableId, indexId, descMock,
testRevisionRegister.actualToken() + 1);
testRevisionRegister.moveForward();
- SchemaPlus schema2 = sqlSchemaManager.schema("PUBLIC");
+ SchemaPlus schema2 = sqlSchemaManager.latestSchema(SCHEMA_NAME);
// Validate schema snapshot.
assertNotSame(schema1, schema2);
@@ -266,11 +265,11 @@ public class SqlSchemaManagerTest extends
BaseIgniteAbstractTest {
assertNotNull(((IgniteTable)
schema2.getTable("T")).getIndex(idxName));
}
{
- sqlSchemaManager.onIndexDropped("PUBLIC", table.tableId(),
indexId, testRevisionRegister.actualToken() + 1);
- SchemaPlus schema1 = sqlSchemaManager.schema("PUBLIC");
+ sqlSchemaManager.onIndexDropped(SCHEMA_NAME, table.tableId(),
indexId, testRevisionRegister.actualToken() + 1);
+ SchemaPlus schema1 = sqlSchemaManager.latestSchema(SCHEMA_NAME);
testRevisionRegister.moveForward();
- SchemaPlus schema2 = sqlSchemaManager.schema("PUBLIC");
+ SchemaPlus schema2 = sqlSchemaManager.latestSchema(SCHEMA_NAME);
// Validate schema snapshot.
assertNotSame(schema1, schema2);
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/PredefinedSchemaManager.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/PredefinedSchemaManager.java
index c98b745510..e497e2564f 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/PredefinedSchemaManager.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/PredefinedSchemaManager.java
@@ -17,13 +17,15 @@
package org.apache.ignite.internal.sql.engine.framework;
+import static java.util.concurrent.CompletableFuture.completedFuture;
+import static java.util.function.Function.identity;
+import static
org.apache.ignite.internal.util.CollectionUtils.toIntMapCollector;
+
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Collection;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
import java.util.concurrent.CompletableFuture;
-import java.util.function.Function;
-import java.util.stream.Collectors;
import org.apache.calcite.schema.SchemaPlus;
import org.apache.calcite.tools.Frameworks;
import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
@@ -42,7 +44,7 @@ import org.jetbrains.annotations.Nullable;
*/
public class PredefinedSchemaManager implements SqlSchemaManager {
private final SchemaPlus root;
- private final Map<Integer, IgniteTable> tableById;
+ private final Int2ObjectMap<IgniteTable> tableById;
/** Constructs schema manager from a single schema. */
PredefinedSchemaManager(IgniteSchema schema) {
@@ -52,7 +54,7 @@ public class PredefinedSchemaManager implements
SqlSchemaManager {
/** Constructs schema manager from a collection of schemas. */
PredefinedSchemaManager(Collection<IgniteSchema> schemas) {
this.root = Frameworks.createRootSchema(false);
- this.tableById = new HashMap<>();
+ this.tableById = new Int2ObjectOpenHashMap<>();
for (IgniteSchema schema : schemas) {
root.add(schema.getName(), schema);
@@ -61,33 +63,27 @@ public class PredefinedSchemaManager implements
SqlSchemaManager {
schema.getTableNames().stream()
.map(schema::getTable)
.map(IgniteTable.class::cast)
- .collect(Collectors.toMap(IgniteTable::id,
Function.identity()))
+ .collect(toIntMapCollector(IgniteTable::id,
identity()))
);
}
}
/** {@inheritDoc} */
@Override
- public SchemaPlus schema(@Nullable String schema) {
- return schema == null ? root : root.getSubSchema(schema);
- }
-
- /** {@inheritDoc} */
- @Override
- public SchemaPlus schema(String name, int version) {
- return schema(name);
+ public SchemaPlus schema(@Nullable String name, int version) {
+ return name == null ? root : root.getSubSchema(name);
}
/** {@inheritDoc} */
@Override
- public CompletableFuture<?> actualSchemaAsync(long ver) {
- return CompletableFuture.completedFuture(root);
+ public SchemaPlus schema(@Nullable String name, long timestamp) {
+ return name == null ? root : root.getSubSchema(name);
}
/** {@inheritDoc} */
@Override
- public SchemaPlus activeSchema(@Nullable String name, long timestamp) {
- return schema(name);
+ public CompletableFuture<Void> schemaReadyFuture(long version) {
+ return completedFuture(null);
}
/** {@inheritDoc} */
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestNode.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestNode.java
index 5cf322fc81..3eaa2abc2d 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestNode.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestNode.java
@@ -29,6 +29,7 @@ import java.util.List;
import java.util.stream.Collectors;
import org.apache.calcite.schema.SchemaPlus;
import org.apache.calcite.tools.Frameworks;
+import org.apache.ignite.internal.catalog.CatalogService;
import org.apache.ignite.internal.metrics.MetricManager;
import org.apache.ignite.internal.sql.engine.AsyncCursor;
import org.apache.ignite.internal.sql.engine.QueryCancel;
@@ -103,7 +104,7 @@ public class TestNode implements LifecycleAware {
this.nodeName = nodeName;
var ps = new PrepareServiceImpl(nodeName, 0,
mock(DdlSqlToCommandConverter.class), PLANNING_TIMEOUT,
mock(MetricManager.class));
this.prepareService = registerService(ps);
- this.schema = schemaManager.schema("PUBLIC");
+ this.schema = schemaManager.schema(CatalogService.DEFAULT_SCHEMA_NAME,
-1);
TopologyService topologyService = clusterService.topologyService();
MessagingService messagingService = clusterService.messagingService();
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManagerTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManagerTest.java
index 18b64e3644..6deea7d40d 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManagerTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManagerTest.java
@@ -99,7 +99,7 @@ public class CatalogSqlSchemaManagerTest {
testSchema.init(catalogManager);
SqlSchemaManager sqlSchemaManager = newSchemaManager();
- SchemaPlus schemaPlus = sqlSchemaManager.activeSchema(testSchema.name,
testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
assertEquals(testSchema.name, schema.getName());
@@ -156,7 +156,7 @@ public class CatalogSqlSchemaManagerTest {
testSchema.init(catalogManager);
SqlSchemaManager sqlSchemaManager = newSchemaManager();
- SchemaPlus schemaPlus = sqlSchemaManager.activeSchema(testSchema.name,
testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
IgniteSchemaTable table = getTable(schema, testTable);
@@ -197,7 +197,7 @@ public class CatalogSqlSchemaManagerTest {
SqlSchemaManager sqlSchemaManager = newSchemaManager();
{
- SchemaPlus schemaPlus =
sqlSchemaManager.activeSchema(testSchema.name, testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
assertEquals(DEFAULT_SCHEMA_NAME, schema.getName());
@@ -205,7 +205,7 @@ public class CatalogSqlSchemaManagerTest {
}
{
- SchemaPlus schemaPlus = sqlSchemaManager.activeSchema(null,
testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(null,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
assertEquals(DEFAULT_SCHEMA_NAME, schema.getName());
@@ -234,7 +234,7 @@ public class CatalogSqlSchemaManagerTest {
testSchema.init(catalogManager);
SqlSchemaManager sqlSchemaManager = newSchemaManager();
- SchemaPlus schemaPlus = sqlSchemaManager.activeSchema(testSchema.name,
testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
IgniteTable table = getTable(schema, testTable);
@@ -274,7 +274,7 @@ public class CatalogSqlSchemaManagerTest {
testSchema.init(catalogManager);
SqlSchemaManager sqlSchemaManager = newSchemaManager();
- SchemaPlus schemaPlus = sqlSchemaManager.activeSchema(testSchema.name,
testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
IgniteTable table = (IgniteTable) schema.getTable(testTable.name);
@@ -302,7 +302,7 @@ public class CatalogSqlSchemaManagerTest {
testSchema.init(catalogManager);
SqlSchemaManager sqlSchemaManager = newSchemaManager();
- SchemaPlus schemaPlus = sqlSchemaManager.activeSchema(testSchema.name,
testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
IgniteTable table = (IgniteTable) schema.getTable(testTable.name);
@@ -336,7 +336,7 @@ public class CatalogSqlSchemaManagerTest {
testSchema.init(catalogManager);
SqlSchemaManager sqlSchemaManager = newSchemaManager();
- SchemaPlus schemaPlus = sqlSchemaManager.activeSchema(testSchema.name,
testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
IgniteTable table = (IgniteTable) schema.getTable(testTable.name);
@@ -369,7 +369,7 @@ public class CatalogSqlSchemaManagerTest {
testSchema.init(catalogManager);
SqlSchemaManager sqlSchemaManager = newSchemaManager();
- SchemaPlus schemaPlus = sqlSchemaManager.activeSchema(testSchema.name,
testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
IgniteSchemaTable table = (IgniteSchemaTable)
schema.getTable(testTable.name);
@@ -413,7 +413,7 @@ public class CatalogSqlSchemaManagerTest {
testSchema.init(catalogManager);
SqlSchemaManager sqlSchemaManager = newSchemaManager();
- SchemaPlus schemaPlus = sqlSchemaManager.activeSchema(testSchema.name,
testSchema.timestamp);
+ SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name,
testSchema.timestamp);
IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
IgniteSchemaTable table = (IgniteSchemaTable)
schema.getTable(testTable.name);
