You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by am...@apache.org on 2023/08/14 20:17:58 UTC

[ignite-3] branch ignite-19497 updated (b2392423ff -> 8c3867fbcb)

This is an automated email from the ASF dual-hosted git repository.

amashenkov pushed a change to branch ignite-19497
in repository https://gitbox.apache.org/repos/asf/ignite-3.git


    omit b2392423ff Minors after review.
    omit 111680d1a7 fix imports
    omit 9b5d2968dc Improve table cache.
    omit 1620aacf17 Fix TODO.
    omit 05e15ebcca Merge branch 'catalog-feature' into ignite-19497
    omit 3e1d7b1251 minor.
    omit f0dff0b01f Merge branch 'catalog-feature' into ignite-19497
    omit f419bc02b3 fix tests.
    omit f03ccfc596 Fix platforms tests
    omit 3759c439ed wip.
    omit f4a6b5caff wip.
    omit 69bae51e47 Merge branch 'catalog-feature' into ignite-19497
    omit c75920b7fd wip.
    omit 4ba6aeb987 set scalar cache initial size equal to max size.
    omit 22d8c3f6b2 Fix varlen column descriptor.
    omit a27d3eaba2 Merge branch 'catalog-feature' into ignite-19497
    omit 5d2898d31e Revert to lazy index rowtype resolving.
    omit dfe9d9a7b0 Replace IgniteIndex with IgniteSchemaIndex. Drop CatalogColumnDescriptor.
    omit f2b1dbd619 Add a hack to get table by name/correct id.
    omit db62e636ea Fix table-by-name resolution.
    omit f1723a46ba Fix column mapping.
    omit 94d27079f6 Replace old IgniteSchema with new IgniteCatalogSchema.
    omit 476ff65600 Styles.
    omit a25f9c2570 Replace IgniteIndex with IgniteSchemaIndex
    omit 70256a816c Replace IgniteTableImpl with IgniteCatalogImpl.
    omit 0315700a6e Fix HashFunctionFactoryImpl to use specific schema version. Fix SqlSchemaManager interface. Drop unused code.
    omit 4d9c063fdb Use schema versions for queries. * Use actual schema for query in TX. * Pass schema version to remote fragment. * Wait for catalog schema ready on the remote side. * Planner cache use catalog version.
    omit ad15215f93 Fix incorrect IgniteSchemaTable.unwrap.
     add 960ce0a72d IGNITE-19294 Support merged configuration roots for multiple modules (#2386)
     add 76410e1f86 IGNITE-19995 testMultithreadedWaitForWithValue muted (#2438)
     add 791abd1831 IGNITE-19789 Sql. Introduce RowSchema for RowFactory (#2398)
     add 3efece8245 IGNITE-19919 Sql. ResultSet#close should close implicit transaction if any (#2423)
     add 027bdd1681 IGNITE-20200 Fix Gradle non-zero exit code on test failure (#2442)
     add af65a70c4c IGNITE-20053 ItRebalanceDistributedTest fixed (#2433)
     add a5a7bac093 IGNITE-20030 Sql. Delete operation fails if PK is set on arbitrary columns (#2397)
     add cfe909d121 IGNITE-19936  Add username and password parameters to the connect command (#2339)
     add c00e7ed902 IGNITE-20192 Fix default length for variable-length columns (#2435)
     add dca21e4492 Merge branch 'main' into catalog-feature
     new ee9b4bbd20 Fix compilation for feature branch.
     new 08c1f65a1d Use CalciteSqlSchemaManager
     new 8c3867fbcb Switch to schema objects based on catalog.

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (b2392423ff)
            \
             N -- N -- N   refs/heads/ignite-19497 (8c3867fbcb)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 buildscripts/java-core.gradle                      |   2 +
 .../internal/catalog/commands/CatalogUtils.java    |   1 +
 .../cli/commands/connect/ItConnectCommandTest.java |  23 +++
 ...tConnectWithBasicAuthenticationCommandTest.java | 193 +++++++++++++++++-
 .../apache/ignite/internal/cli/ssl/ItSslTest.java  |   4 +-
 .../internal/cli/call/connect/ConnectCall.java     | 104 ++++++----
 .../cli/call/connect/ConnectCallInput.java         | 105 ++++++++++
 .../internal/cli/call/connect/ConnectSslCall.java  |   7 +-
 .../cli/call/connect/ConnectSslConfigCall.java     |   3 +-
 .../internal/cli/call/connect/DisconnectCall.java  |  14 +-
 .../ignite/internal/cli/commands/Options.java      |  18 ++
 .../cli/commands/connect/ConnectCommand.java       |  16 +-
 .../ConnectOptions.java}                           |  47 +++--
 .../cli/commands/connect/ConnectReplCommand.java   |  28 ++-
 .../questions/ConnectToClusterQuestion.java        |  33 ++-
 .../ignite/internal/cli/config/ConfigManager.java  |   4 +
 .../handler/IgniteCliApiExceptionHandler.java      |   7 +-
 .../cli/core/repl/ConnectionHeartBeat.java         |   2 +-
 .../ignite/internal/cli/core/repl/SessionInfo.java |   5 +-
 .../internal/cli/core/rest/ApiClientFactory.java   |  80 ++++++--
 .../cli/commands/connect/ConnectCommandTest.java   |  48 +++++
 ...tibleSchemaAnnotations0ConfigurationSchema.java |   6 +-
 .../ErrorInjectedName4ConfigurationSchema.java     |   6 +-
 .../ErrorInjectedName5ConfigurationSchema.java     |   4 +-
 .../ErrorInternal0ConfigurationSchema.java         |   6 +-
 .../ErrorInternal1ConfigurationSchema.java         |   6 +-
 .../ErrorInternal2ConfigurationSchema.java         |   6 +-
 .../ErrorInternal3ConfigurationSchema.java         |   6 +-
 .../ErrorInternal4ConfigurationSchema.java         |   4 +-
 .../ErrorInternal5ConfigurationSchema.java         |   4 +-
 .../ExtendedSimpleConfigurationSchema.java         |   4 +-
 .../ExtendedSimpleRootConfigurationSchema.java     |   4 +-
 .../ErrorPolymorphic2ConfigurationSchema.java      |   6 +-
 ...rorPolymorphicInstance2ConfigurationSchema.java |   6 +-
 .../processor/ConfigurationProcessor.java          |  32 +--
 .../ignite/configuration/ConfigurationModule.java  |  14 +-
 .../org/apache/ignite/configuration/RootKey.java   |  10 +-
 ...figuration.java => ConfigurationExtension.java} |  12 +-
 modules/configuration/README.md                    |  76 +++++++
 .../configuration/ConfigurationTreeGenerator.java  |  30 +--
 .../configuration/DynamicConfiguration.java        |   7 +-
 .../configuration/NamedListConfiguration.java      |   2 +-
 .../internal/configuration/RootInnerNode.java      |   4 +-
 .../configuration/asm/AbstractAsmGenerator.java    |  19 +-
 .../asm/ConfigurationAsmGenerator.java             |  47 +++--
 .../asm/ConfigurationImplAsmGenerator.java         |  73 +++----
 .../configuration/asm/DirectProxyAsmGenerator.java |  14 +-
 .../configuration/asm/InnerNodeAsmGenerator.java   |  94 ++++-----
 .../internal/configuration/tree/InnerNode.java     |   7 +-
 .../configuration/util/ConfigurationUtil.java      |  52 +++--
 .../validation/ConfigurationValidatorImpl.java     |   6 +-
 .../configuration/ConfigurationRegistryTest.java   |   4 +-
 .../asm/ConfigurationTreeGeneratorTest.java        |  44 +++-
 .../notifications/ConfigurationListenerTest.java   |   4 +-
 .../ExtendedDiscoveryConfigurationSchema.java      |   4 +-
 .../testframework/ConfigurationExtensionTest.java  |   8 +-
 .../configuration/tree/InternalIdTest.java         |   4 +-
 .../configuration/util/ConfigurationUtilTest.java  | 226 +++++++++++++++++++--
 .../validation/ConfigurationValidatorImplTest.java |   4 +-
 .../testframework/ConfigurationExtension.java      |  23 +--
 .../testframework/ExtendedConfigurationSchema.java |   4 +-
 .../testframework/InjectConfiguration.java         |   6 +-
 .../util/PendingComparableValuesTrackerTest.java   |   1 +
 .../ignite/jdbc/ItJdbcStatementSelfTest.java       |   3 +-
 .../configuration/generator/DefaultsGenerator.java |   2 +-
 .../storage/ItRebalanceDistributedTest.java        |  42 ++--
 ...niteDistributionZoneManagerNodeRestartTest.java |   4 +-
 .../runner/app/ItIgniteNodeRestartTest.java        |   4 +-
 .../runner/app/PlatformTestNodeRunner.java         |   6 +-
 .../ignite/internal/sql/api/ItCommonApiTest.java   |   1 +
 .../internal/sql/api/ItSqlAsynchronousApiTest.java |  41 ++++
 .../internal/sql/api/ItSqlSynchronousApiTest.java  |  53 ++++-
 .../ignite/internal/sql/engine/ItDmlTest.java      |  19 ++
 .../internal/sql/engine/ItSqlOperatorsTest.java    |   2 +
 .../org/apache/ignite/internal/app/IgniteImpl.java |   4 +-
 .../internal/configuration/CompoundModule.java     |   4 +-
 .../internal/configuration/CompoundModuleTest.java |   6 +-
 .../ExtendedTableConfigurationSchema.java          |   4 +-
 .../SchemaDistributedConfigurationModule.java      |   2 +-
 .../SchemaDistributedConfigurationModuleTest.java  |   2 +-
 .../schema/testutils/definition/ColumnType.java    |   2 +-
 .../SecurityConfigurationModuleTest.java           |   4 +-
 .../internal/sql/engine/AsyncSqlCursorImpl.java    |   4 +
 .../internal/sql/engine/exec/ArrayRowHandler.java  |   6 +-
 .../sql/engine/exec/LogicalRelImplementor.java     |  51 +++--
 .../internal/sql/engine/exec/RowConverter.java     |   2 +-
 .../internal/sql/engine/exec/RowHandler.java       |  34 +---
 .../internal/sql/engine/exec/ScannableTable.java   |   4 +-
 .../sql/engine/exec/ScannableTableImpl.java        |   5 +-
 .../sql/engine/exec/UpdatableTableImpl.java        | 110 ++++++----
 .../sql/engine/exec/exp/ExpressionFactoryImpl.java |  33 ++-
 .../sql/engine/exec/rel/IndexScanNode.java         |  12 +-
 .../sql/engine/exec/rel/MergeJoinNode.java         |  15 +-
 .../internal/sql/engine/exec/rel/ModifyNode.java   |   9 +-
 .../sql/engine/exec/rel/NestedLoopJoinNode.java    |  15 +-
 .../sql/engine/exec/row/BaseTypeSpec.java}         |  59 +++---
 .../sql/engine/exec/row/NullTypeSpec.java}         |  34 ++--
 .../internal/sql/engine/exec/row/RowSchema.java    | 104 ++++++++++
 .../sql/engine/exec/row/RowSchemaTypes.java        |  85 ++++++++
 .../MultiBounds.java => exec/row/RowType.java}     |  46 ++---
 .../internal/sql/engine/exec/row/TypeSpec.java}    |  33 ++-
 .../sql/engine/prepare/IgniteTypeCoercion.java     |   2 +-
 .../internal/sql/engine/rel/AbstractIndexScan.java |   7 +-
 .../sql/engine/rule/TableModifyConverterRule.java  |  27 ++-
 .../internal/sql/engine/schema/IgniteIndex.java    |  23 ++-
 .../sql/engine/schema/IgniteSchemaTable.java       |  21 --
 .../internal/sql/engine/schema/IgniteTable.java    |  25 ---
 .../ignite/internal/sql/engine/util/TypeUtils.java |  75 ++++++-
 .../sql/engine/AsyncSqlCursorImplTest.java         | 117 +++++++++++
 .../sql/engine/exec/ExecutionServiceImplTest.java  |   1 -
 .../sql/engine/exec/rel/ExecutionTest.java         |  16 +-
 .../exec/rel/IndexScanNodeExecutionTest.java       |  17 +-
 .../engine/exec/rel/ScannableTableSelfTest.java    |  36 ++--
 .../exec/rel/TableScanNodeExecutionTest.java       |  10 +-
 .../sql/engine/exec/row/RowSchemaTest.java         |  76 +++++++
 .../sql/engine/exec/row/RowSchemaTypesTest.java    | 221 ++++++++++++++++++++
 .../sql/engine/framework/NoOpTransaction.java      |  24 ++-
 .../engine/framework/PredefinedSchemaManager.java  |   7 +-
 .../sql/engine/framework/TestBuilders.java         |  14 +-
 .../internal/sql/engine/framework/TestNode.java    |   2 +-
 .../internal/sql/engine/framework/TestTable.java   |  14 --
 .../sql/engine/planner/DmlPlannerTest.java         |  38 ++++
 .../engine/planner/JoinColocationPlannerTest.java  |   2 +-
 .../sql/engine/prepare/TypeCoercionTest.java       |  13 --
 .../internal/sql/engine/util/TypeUtilsTest.java    | 180 ++++++++++++++++
 .../distributed/storage/InternalTableImpl.java     |   2 +-
 126 files changed, 2721 insertions(+), 758 deletions(-)
 create mode 100644 modules/cli/src/main/java/org/apache/ignite/internal/cli/call/connect/ConnectCallInput.java
 copy modules/cli/src/main/java/org/apache/ignite/internal/cli/commands/{BaseCommand.java => connect/ConnectOptions.java} (60%)
 rename modules/configuration-api/src/main/java/org/apache/ignite/configuration/annotation/{InternalConfiguration.java => ConfigurationExtension.java} (74%)
 copy modules/{schema/src/main/java/org/apache/ignite/internal/schema/DecimalNativeType.java => sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/row/BaseTypeSpec.java} (53%)
 copy modules/{schema/src/testFixtures/java/org/apache/ignite/internal/schema/testutils/definition/AbstractSchemaObject.java => sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/row/NullTypeSpec.java} (63%)
 create mode 100644 modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/row/RowSchema.java
 create mode 100644 modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/row/RowSchemaTypes.java
 copy modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/{prepare/bounds/MultiBounds.java => exec/row/RowType.java} (59%)
 copy modules/{network/src/test/java/org/apache/ignite/internal/network/serialization/marshal/IntHolder.java => sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/row/TypeSpec.java} (68%)
 create mode 100644 modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/AsyncSqlCursorImplTest.java
 create mode 100644 modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/row/RowSchemaTest.java
 create mode 100644 modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/row/RowSchemaTypesTest.java


[ignite-3] 02/03: Use CalciteSqlSchemaManager

Posted by am...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

amashenkov pushed a commit to branch ignite-19497
in repository https://gitbox.apache.org/repos/asf/ignite-3.git

commit 08c1f65a1df5f9c2ea25382999a8f11b2157bfc8
Author: amashenkov <an...@gmail.com>
AuthorDate: Mon Aug 14 17:17:03 2023 +0300

    Use CalciteSqlSchemaManager
---
 .../ignite/internal/sql/api/ItCommonApiTest.java   |   2 +-
 .../internal/sql/engine/SqlQueryProcessor.java     | 147 +-----
 .../engine/exec/ExecutionDependencyResolver.java   |   2 +-
 .../exec/ExecutionDependencyResolverImpl.java      |   2 +-
 .../sql/engine/exec/ExecutionServiceImpl.java      |   6 +-
 .../sql/engine/message/QueryStartRequest.java      |   2 +-
 .../sql/engine/schema/CatalogSqlSchemaManager.java |   4 +-
 .../internal/sql/engine/schema/IgniteSchema.java   |  12 +-
 .../sql/engine/schema/IgniteTableImpl.java         | 276 ----------
 .../sql/engine/schema/SqlSchemaManager.java        |   2 +-
 .../sql/engine/schema/SqlSchemaManagerImpl.java    | 585 ---------------------
 .../internal/sql/engine/util/BaseQueryContext.java |   2 +-
 .../sql/engine/exec/ExecutionServiceImplTest.java  |   2 +-
 .../engine/exec/schema/SqlSchemaManagerTest.java   | 328 ------------
 .../engine/framework/PredefinedSchemaManager.java  |   2 +-
 15 files changed, 26 insertions(+), 1348 deletions(-)

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 a35bbc7fb0..302b67daee 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
@@ -230,7 +230,7 @@ public class ItCommonApiTest extends ClusterPerClassIntegrationTest {
 
         /** {@inheritDoc} */
         @Override
-        public CompletableFuture<Void> schemaReadyFuture(long version) {
+        public CompletableFuture<Void> schemaReadyFuture(int 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 e20384c7f4..0657622a10 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
@@ -46,7 +46,6 @@ 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;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.Event;
@@ -71,8 +70,8 @@ import org.apache.ignite.internal.sql.engine.prepare.PrepareService;
 import org.apache.ignite.internal.sql.engine.prepare.PrepareServiceImpl;
 import org.apache.ignite.internal.sql.engine.property.PropertiesHelper;
 import org.apache.ignite.internal.sql.engine.property.PropertiesHolder;
+import org.apache.ignite.internal.sql.engine.schema.CatalogSqlSchemaManager;
 import org.apache.ignite.internal.sql.engine.schema.SqlSchemaManager;
-import org.apache.ignite.internal.sql.engine.schema.SqlSchemaManagerImpl;
 import org.apache.ignite.internal.sql.engine.session.Session;
 import org.apache.ignite.internal.sql.engine.session.SessionId;
 import org.apache.ignite.internal.sql.engine.session.SessionInfo;
@@ -89,7 +88,6 @@ import org.apache.ignite.internal.sql.metrics.SqlClientMetricSource;
 import org.apache.ignite.internal.storage.DataStorageManager;
 import org.apache.ignite.internal.table.distributed.TableManager;
 import org.apache.ignite.internal.table.event.TableEvent;
-import org.apache.ignite.internal.table.event.TableEventParameters;
 import org.apache.ignite.internal.tx.InternalTransaction;
 import org.apache.ignite.internal.tx.TxManager;
 import org.apache.ignite.internal.util.IgniteSpinBusyLock;
@@ -99,7 +97,6 @@ import org.apache.ignite.lang.NodeStoppingException;
 import org.apache.ignite.lang.SchemaNotFoundException;
 import org.apache.ignite.network.ClusterService;
 import org.apache.ignite.sql.SqlException;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 
@@ -118,6 +115,9 @@ public class SqlQueryProcessor implements QueryProcessor {
     /** Size of the table access cache. */
     private static final int TABLE_CACHE_SIZE = 1024;
 
+    /** Size of the schema cache. */
+    private static final int SCHEMA_CACHE_SIZE = 128;
+
     /** Session expiration check period in milliseconds. */
     private static final long SESSION_EXPIRE_CHECK_PERIOD = TimeUnit.SECONDS.toMillis(1);
 
@@ -218,15 +218,10 @@ public class SqlQueryProcessor implements QueryProcessor {
         this.catalogManager = catalogManager;
         this.metricManager = metricManager;
 
-        sqlSchemaManager = new SqlSchemaManagerImpl(
-                tableManager,
-                schemaManager,
-                registry,
-                busyLock
+        sqlSchemaManager = new CatalogSqlSchemaManager(
+                catalogManager,
+                SCHEMA_CACHE_SIZE
         );
-
-        registerTableListener(TableEvent.CREATE, new TableCreatedListener((SqlSchemaManagerImpl) sqlSchemaManager));
-        registerIndexListener(IndexEvent.CREATE, new IndexCreatedListener((SqlSchemaManagerImpl) sqlSchemaManager));
     }
 
     /** {@inheritDoc} */
@@ -262,8 +257,6 @@ public class SqlQueryProcessor implements QueryProcessor {
                 msgSrvc
         ));
 
-        ((SqlSchemaManagerImpl) sqlSchemaManager).registerListener(prepareSvc);
-
         this.prepareSvc = prepareSvc;
 
         var ddlCommandHandler = new DdlCommandHandlerWrapper(
@@ -278,8 +271,6 @@ public class SqlQueryProcessor implements QueryProcessor {
 
         var dependencyResolver = new ExecutionDependencyResolverImpl(executableTableRegistry);
 
-        ((SqlSchemaManagerImpl) sqlSchemaManager).registerListener(executableTableRegistry);
-
         var executionSrvc = registerService(ExecutionServiceImpl.create(
                 clusterSrvc.topologyService(),
                 msgSrvc,
@@ -297,11 +288,6 @@ public class SqlQueryProcessor implements QueryProcessor {
 
         this.executionSrvc = executionSrvc;
 
-        registerTableListener(TableEvent.ALTER, new TableUpdatedListener(((SqlSchemaManagerImpl) sqlSchemaManager)));
-        registerTableListener(TableEvent.DROP, new TableDroppedListener(((SqlSchemaManagerImpl) sqlSchemaManager)));
-
-        registerIndexListener(IndexEvent.DROP, new IndexDroppedListener(((SqlSchemaManagerImpl) sqlSchemaManager)));
-
         services.forEach(LifecycleAware::start);
     }
 
@@ -383,18 +369,6 @@ public class SqlQueryProcessor implements QueryProcessor {
         return service;
     }
 
-    private void registerTableListener(TableEvent evt, AbstractTableEventListener lsnr) {
-        evtLsnrs.add(Pair.of(evt, lsnr));
-
-        tableManager.listen(evt, lsnr);
-    }
-
-    private void registerIndexListener(IndexEvent evt, AbstractIndexEventListener lsnr) {
-        evtLsnrs.add(Pair.of(evt, lsnr));
-
-        indexManager.listen(evt, lsnr);
-    }
-
     private CompletableFuture<AsyncSqlCursor<List<Object>>> querySingle0(
             SessionId sessionId,
             QueryContext context,
@@ -520,113 +494,6 @@ public class SqlQueryProcessor implements QueryProcessor {
         return metricManager;
     }
 
-    private abstract static class AbstractTableEventListener implements EventListener<TableEventParameters> {
-        protected final SqlSchemaManagerImpl schemaHolder;
-
-        private AbstractTableEventListener(SqlSchemaManagerImpl schemaHolder) {
-            this.schemaHolder = schemaHolder;
-        }
-    }
-
-    private abstract static class AbstractIndexEventListener implements EventListener<IndexEventParameters> {
-        protected final SqlSchemaManagerImpl schemaHolder;
-
-        private AbstractIndexEventListener(SqlSchemaManagerImpl schemaHolder) {
-            this.schemaHolder = schemaHolder;
-        }
-    }
-
-    private static class TableCreatedListener extends AbstractTableEventListener {
-        private TableCreatedListener(SqlSchemaManagerImpl schemaHolder) {
-            super(schemaHolder);
-        }
-
-        /** {@inheritDoc} */
-        @Override
-        public CompletableFuture<Boolean> notify(@NotNull TableEventParameters parameters, @Nullable Throwable exception) {
-            return schemaHolder.onTableCreated(
-                    // TODO: https://issues.apache.org/jira/browse/IGNITE-17694 Hardcoded schemas
-                    DEFAULT_SCHEMA_NAME,
-                    parameters.tableId(),
-                    parameters.causalityToken()
-            )
-                    .thenApply(v -> false);
-        }
-    }
-
-    private static class TableUpdatedListener extends AbstractTableEventListener {
-        private TableUpdatedListener(SqlSchemaManagerImpl schemaHolder) {
-            super(schemaHolder);
-        }
-
-        /** {@inheritDoc} */
-        @Override
-        public CompletableFuture<Boolean> notify(@NotNull TableEventParameters parameters, @Nullable Throwable exception) {
-            return schemaHolder.onTableUpdated(
-                    // TODO: https://issues.apache.org/jira/browse/IGNITE-17694 Hardcoded schemas
-                    DEFAULT_SCHEMA_NAME,
-                    parameters.tableId(),
-                    parameters.causalityToken()
-            )
-                    .thenApply(v -> false);
-        }
-    }
-
-    private static class TableDroppedListener extends AbstractTableEventListener {
-        private TableDroppedListener(SqlSchemaManagerImpl schemaHolder) {
-            super(schemaHolder);
-        }
-
-        /** {@inheritDoc} */
-        @Override
-        public CompletableFuture<Boolean> notify(@NotNull TableEventParameters parameters, @Nullable Throwable exception) {
-            return schemaHolder.onTableDropped(
-                    // TODO: https://issues.apache.org/jira/browse/IGNITE-17694 Hardcoded schemas
-                    DEFAULT_SCHEMA_NAME,
-                    parameters.tableId(),
-                    parameters.causalityToken()
-            )
-                    .thenApply(v -> false);
-        }
-    }
-
-    private static class IndexDroppedListener extends AbstractIndexEventListener {
-        private IndexDroppedListener(SqlSchemaManagerImpl schemaHolder) {
-            super(schemaHolder);
-        }
-
-        /** {@inheritDoc} */
-        @Override
-        public CompletableFuture<Boolean> notify(@NotNull IndexEventParameters parameters, @Nullable Throwable exception) {
-            return schemaHolder.onIndexDropped(
-                    // TODO: https://issues.apache.org/jira/browse/IGNITE-17694 Hardcoded schemas
-                    DEFAULT_SCHEMA_NAME,
-                    parameters.tableId(),
-                    parameters.indexId(),
-                    parameters.causalityToken()
-            )
-                    .thenApply(v -> false);
-        }
-    }
-
-    private static class IndexCreatedListener extends AbstractIndexEventListener {
-        private IndexCreatedListener(SqlSchemaManagerImpl schemaHolder) {
-            super(schemaHolder);
-        }
-
-        /** {@inheritDoc} */
-        @Override
-        public CompletableFuture<Boolean> notify(@NotNull IndexEventParameters parameters, @Nullable Throwable exception) {
-            return schemaHolder.onIndexCreated(
-                    parameters.tableId(),
-                    parameters.indexId(),
-                    parameters.indexDescriptor(),
-                    parameters.causalityToken()
-            )
-                    .thenApply(v -> false);
-        }
-    }
-
     /** Returns {@code true} if this is data modification operation. */
     private static boolean dataModificationOp(ParsedResult parsedResult) {
         return parsedResult.queryType() == SqlQueryType.DML;
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolver.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolver.java
index b2bf565ccc..c86475a561 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolver.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolver.java
@@ -29,5 +29,5 @@ public interface ExecutionDependencyResolver {
     /**
      * Resolves dependencies required to execute the given list of relations.
      */
-    CompletableFuture<ResolvedDependencies> resolveDependencies(Iterable<IgniteRel> rels, long schemaVersion);
+    CompletableFuture<ResolvedDependencies> resolveDependencies(Iterable<IgniteRel> rels, int schemaVersion);
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverImpl.java
index a225231077..e8bb7b7052 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverImpl.java
@@ -47,7 +47,7 @@ public class ExecutionDependencyResolverImpl implements ExecutionDependencyResol
      * {@inheritDoc}
      */
     @Override
-    public CompletableFuture<ResolvedDependencies> resolveDependencies(Iterable<IgniteRel> rels, long schemaVersion) {
+    public CompletableFuture<ResolvedDependencies> resolveDependencies(Iterable<IgniteRel> rels, int schemaVersion) {
         Map<Integer, CompletableFuture<ExecutableTable>> tableMap = new HashMap<>();
 
         IgniteRelShuttle shuttle = new IgniteRelShuttle() {
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 420a5f11be..0e63ecd898 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, long schemaVersion, @Nullable String schema, Object[] params) {
+    private BaseQueryContext createQueryContext(UUID queryId, int schemaVersion, @Nullable String schema, Object[] params) {
         return BaseQueryContext.builder()
                 .queryId(queryId)
                 .parameters(params)
                 .frameworkConfig(
                         Frameworks.newConfigBuilder(FRAMEWORK_CONFIG)
-                                .defaultSchema(sqlSchemaManager.schema(schema, (int) schemaVersion))
+                                .defaultSchema(sqlSchemaManager.schema(schema, schemaVersion))
                                 .build()
                 )
                 .logger(LOG)
@@ -606,7 +606,7 @@ public class ExecutionServiceImpl<RowT> implements ExecutionService, TopologyEve
 
             start.thenCompose(none -> {
                 IgniteRel treeRoot = relationalTreeFromJsonString(fragmentString, ctx);
-                long schemaVersion = ctx.schemaVersion();
+                int schemaVersion = ctx.schemaVersion();
 
                 return dependencyResolver.resolveDependencies(List.of(treeRoot), schemaVersion).thenComposeAsync(deps -> {
                     return executeFragment(treeRoot, deps, context);
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/message/QueryStartRequest.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/message/QueryStartRequest.java
index f104188038..48edad43cc 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/message/QueryStartRequest.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/message/QueryStartRequest.java
@@ -58,5 +58,5 @@ public interface QueryStartRequest extends ExecutionContextAwareMessage {
     /**
      * Return last schema version, just a stub, need to be removed after IGNITE-18733.
      */
-    long schemaVersion();
+    int schemaVersion();
 }
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 110a6168e8..f8cd38e680 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
@@ -98,9 +98,9 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
 
     /** {@inheritDoc} */
     @Override
-    public CompletableFuture<Void> schemaReadyFuture(long version) {
+    public CompletableFuture<Void> schemaReadyFuture(int version) {
         // SqlSchemaManager creates SQL schema lazily on-demand, thus waiting for Catalog version is enough.
-        return catalogManager.catalogReadyFuture((int) version);
+        return catalogManager.catalogReadyFuture(version);
     }
 
     private static SchemaPlus createSqlSchema(int version, CatalogSchemaDescriptor schemaDescriptor) {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchema.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchema.java
index 27320aa2a8..8163917c19 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchema.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchema.java
@@ -28,7 +28,7 @@ import org.jetbrains.annotations.Nullable;
  * Ignite schema.
  */
 public class IgniteSchema extends AbstractSchema {
-    static final long INITIAL_VERSION = -1;
+    static final int INITIAL_VERSION = -1;
 
     private final String schemaName;
 
@@ -36,7 +36,7 @@ public class IgniteSchema extends AbstractSchema {
 
     private final Map<Integer, IgniteIndex> idxMap;
 
-    private final long schemaVersion;
+    private final int schemaVersion;
 
     /**
      * Creates a Schema with given tables and indexes.
@@ -49,7 +49,7 @@ public class IgniteSchema extends AbstractSchema {
             String schemaName,
             @Nullable Map<String, Table> tableMap,
             @Nullable Map<Integer, IgniteIndex> indexMap,
-            long schemaVersion
+            int schemaVersion
     ) {
         this.schemaName = schemaName;
         this.tblMap = tableMap == null ? new ConcurrentHashMap<>() : new ConcurrentHashMap<>(tableMap);
@@ -71,11 +71,11 @@ public class IgniteSchema extends AbstractSchema {
      *
      * @param schemaName A name of the schema to create.
      */
-    public IgniteSchema(String schemaName, long schemaVersion) {
+    public IgniteSchema(String schemaName, int schemaVersion) {
         this(schemaName, null, null, schemaVersion);
     }
 
-    public static IgniteSchema copy(IgniteSchema old, long schemaVersion) {
+    public static IgniteSchema copy(IgniteSchema old, int schemaVersion) {
         return new IgniteSchema(old.schemaName, old.tblMap, old.idxMap, schemaVersion);
     }
 
@@ -145,7 +145,7 @@ public class IgniteSchema extends AbstractSchema {
     /**
      * Return actual schema version.
      */
-    public long schemaVersion() {
+    public int schemaVersion() {
         return schemaVersion;
     }
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteTableImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteTableImpl.java
deleted file mode 100644
index 3b4003d442..0000000000
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteTableImpl.java
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- * 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.internal.sql.engine.schema;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.DoubleSupplier;
-import org.apache.calcite.plan.Convention;
-import org.apache.calcite.plan.RelOptCluster;
-import org.apache.calcite.plan.RelOptTable;
-import org.apache.calcite.plan.RelTraitSet;
-import org.apache.calcite.rel.RelCollation;
-import org.apache.calcite.rel.RelCollations;
-import org.apache.calcite.rel.hint.RelHint;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.rex.RexNode;
-import org.apache.calcite.schema.Statistic;
-import org.apache.calcite.schema.impl.AbstractTable;
-import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
-import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
-import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan;
-import org.apache.ignite.internal.sql.engine.schema.IgniteIndex.Type;
-import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
-import org.apache.ignite.internal.sql.engine.trait.TraitUtils;
-import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.apache.ignite.internal.storage.MvPartitionStorage;
-import org.apache.ignite.internal.storage.StorageRebalanceException;
-import org.apache.ignite.internal.table.InternalTable;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * Ignite table implementation.
- */
-public class IgniteTableImpl extends AbstractTable implements IgniteTable {
-
-    private final TableDescriptor desc;
-
-    private final int ver;
-
-    private final int id;
-
-    private final String name;
-
-    private final Statistic statistic;
-
-    private final Map<String, IgniteIndex> indexes = new HashMap<>();
-
-    /**
-     * Constructor.
-     *
-     * @param desc Table descriptor.
-     * @param tableId Table id.
-     * @param name Table name.
-     */
-    IgniteTableImpl(TableDescriptor desc, int tableId, String name, int version,
-            DoubleSupplier rowCount) {
-        this.ver = version;
-        this.desc = desc;
-        this.id = tableId;
-        this.name = name;
-        this.statistic = new IgniteStatistic(rowCount, desc.distribution());
-    }
-
-    private IgniteTableImpl(IgniteTableImpl t) {
-        this.desc = t.desc;
-        this.ver = t.ver;
-        this.id = t.id;
-        this.name = t.name;
-        this.statistic = t.statistic;
-        this.indexes.putAll(t.indexes);
-    }
-
-    public static IgniteTableImpl copyOf(IgniteTableImpl v) {
-        return new IgniteTableImpl(v);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public int id() {
-        return id;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public int version() {
-        return ver;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public String name() {
-        return name;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public RelDataType getRowType(RelDataTypeFactory typeFactory, ImmutableBitSet requiredColumns) {
-        return desc.rowType((IgniteTypeFactory) typeFactory, requiredColumns);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public Statistic getStatistic() {
-        return statistic;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public TableDescriptor descriptor() {
-        return desc;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteLogicalTableScan toRel(
-            RelOptCluster cluster,
-            RelOptTable relOptTbl,
-            List<RelHint> hints,
-            @Nullable List<RexNode> proj,
-            @Nullable RexNode cond,
-            @Nullable ImmutableBitSet requiredColumns
-    ) {
-        RelTraitSet traitSet = cluster.traitSetOf(distribution());
-
-        return IgniteLogicalTableScan.create(cluster, traitSet, hints, relOptTbl, proj, cond, requiredColumns);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteLogicalIndexScan toRel(
-            RelOptCluster cluster,
-            RelOptTable relOptTable,
-            String idxName,
-            List<RexNode> proj,
-            RexNode condition,
-            ImmutableBitSet requiredCols
-    ) {
-        IgniteIndex index = getIndex(idxName);
-
-        RelCollation collation = TraitUtils.createCollation(index.columns(), index.collations(), descriptor());
-
-        RelTraitSet traitSet = cluster.traitSetOf(Convention.Impl.NONE)
-                .replace(distribution())
-                .replace(index.type() == Type.HASH ? RelCollations.EMPTY : collation);
-
-        return IgniteLogicalIndexScan.create(cluster, traitSet, relOptTable, idxName, proj, condition, requiredCols);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteDistribution distribution() {
-        return desc.distribution();
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public Map<String, IgniteIndex> indexes() {
-        return Collections.unmodifiableMap(indexes);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public void addIndex(IgniteIndex idxTbl) {
-        indexes.put(idxTbl.name(), idxTbl);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteIndex getIndex(String idxName) {
-        return indexes.get(idxName);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public void removeIndex(String idxName) {
-        indexes.remove(idxName);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public <C> C unwrap(Class<C> cls) {
-        if (cls.isInstance(desc)) {
-            return cls.cast(desc);
-        }
-
-        return super.unwrap(cls);
-    }
-
-    static DoubleSupplier rowCountStatistic(InternalTable table) {
-        return new RowCountStatistic(table);
-    }
-
-    private static final class RowCountStatistic implements DoubleSupplier {
-        private static final int UPDATE_THRESHOLD = DistributionZoneManager.DEFAULT_PARTITION_COUNT;
-
-        private final AtomicLong lastUpd = new AtomicLong();
-
-        private volatile long localRowCnt = 0L;
-
-        private final InternalTable table;
-
-        private RowCountStatistic(InternalTable table) {
-            this.table = table;
-        }
-
-        /** {@inheritDoc} */
-        @Override
-        // TODO: need to be refactored https://issues.apache.org/jira/browse/IGNITE-19558
-        public double getAsDouble() {
-            int parts = table.storage().getTableDescriptor().getPartitions();
-
-            long partitionsRevisionCounter = 0L;
-
-            for (int p = 0; p < parts; ++p) {
-                @Nullable MvPartitionStorage part = table.storage().getMvPartition(p);
-
-                if (part == null) {
-                    continue;
-                }
-
-                long upd = part.lastAppliedIndex();
-
-                partitionsRevisionCounter += upd;
-            }
-
-            long prev = lastUpd.get();
-
-            if (partitionsRevisionCounter - prev > UPDATE_THRESHOLD) {
-                synchronized (this) {
-                    if (lastUpd.compareAndSet(prev, partitionsRevisionCounter)) {
-                        long size = 0L;
-
-                        for (int p = 0; p < parts; ++p) {
-                            @Nullable MvPartitionStorage part = table.storage().getMvPartition(p);
-
-                            if (part == null) {
-                                continue;
-                            }
-
-                            try {
-                                size += part.rowsCount();
-                            } catch (StorageRebalanceException ignore) {
-                                // No-op.
-                            }
-                        }
-
-                        localRowCnt = size;
-                    }
-                }
-            }
-
-            // Forbid zero result, to prevent zero cost for table and index scans.
-            return Math.max(10_000.0, (double) localRowCnt);
-        }
-    }
-}
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 beed01fe86..d07454e2a7 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
@@ -48,5 +48,5 @@ public interface SqlSchemaManager {
      *
      * @param version SQL schema version to wait.
      */
-    CompletableFuture<Void> schemaReadyFuture(long version);
+    CompletableFuture<Void> schemaReadyFuture(int 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
deleted file mode 100644
index c2ec8e2300..0000000000
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManagerImpl.java
+++ /dev/null
@@ -1,585 +0,0 @@
-/*
- * 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.internal.sql.engine.schema;
-
-import static java.util.concurrent.CompletableFuture.completedFuture;
-import static java.util.concurrent.CompletableFuture.failedFuture;
-import static org.apache.ignite.internal.sql.engine.SqlQueryProcessor.DEFAULT_SCHEMA_NAME;
-import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
-import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
-import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
-import static org.apache.ignite.lang.IgniteStringFormatter.format;
-
-import it.unimi.dsi.fastutil.ints.IntArrayList;
-import it.unimi.dsi.fastutil.ints.IntList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.CopyOnWriteArraySet;
-import java.util.function.Consumer;
-import java.util.function.DoubleSupplier;
-import java.util.function.LongFunction;
-import java.util.stream.Collectors;
-import org.apache.calcite.schema.SchemaPlus;
-import org.apache.calcite.tools.Frameworks;
-import org.apache.ignite.internal.causality.CompletableVersionedValue;
-import org.apache.ignite.internal.causality.IncrementalVersionedValue;
-import org.apache.ignite.internal.causality.OutdatedTokenException;
-import org.apache.ignite.internal.index.HashIndex;
-import org.apache.ignite.internal.index.Index;
-import org.apache.ignite.internal.index.IndexDescriptor;
-import org.apache.ignite.internal.index.SortedIndexDescriptor;
-import org.apache.ignite.internal.index.SortedIndexImpl;
-import org.apache.ignite.internal.schema.Column;
-import org.apache.ignite.internal.schema.DefaultValueProvider;
-import org.apache.ignite.internal.schema.DefaultValueProvider.Type;
-import org.apache.ignite.internal.schema.SchemaDescriptor;
-import org.apache.ignite.internal.schema.SchemaManager;
-import org.apache.ignite.internal.schema.SchemaRegistry;
-import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
-import org.apache.ignite.internal.sql.engine.trait.IgniteDistributions;
-import org.apache.ignite.internal.table.InternalTable;
-import org.apache.ignite.internal.table.TableImpl;
-import org.apache.ignite.internal.table.distributed.TableManager;
-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.
- */
-public class SqlSchemaManagerImpl implements SqlSchemaManager {
-    private final IncrementalVersionedValue<Map<String, IgniteSchema>> schemasVv;
-
-    private final IncrementalVersionedValue<Map<Integer, IgniteTable>> tablesVv;
-
-    private final Map<Integer, CompletableFuture<?>> pkIdxReady = new ConcurrentHashMap<>();
-
-    private final IncrementalVersionedValue<Map<Integer, IgniteIndex>> indicesVv;
-
-    private final TableManager tableManager;
-    private final SchemaManager schemaManager;
-
-    private final CompletableVersionedValue<SchemaPlus> calciteSchemaVv;
-
-    private final Set<SchemaUpdateListener> listeners = new CopyOnWriteArraySet<>();
-
-    /** Busy lock for stop synchronisation. */
-    private final IgniteSpinBusyLock busyLock;
-
-    /**
-     * Constructor.
-     * TODO Documentation https://issues.apache.org/jira/browse/IGNITE-15859
-     */
-    public SqlSchemaManagerImpl(
-            TableManager tableManager,
-            SchemaManager schemaManager,
-            Consumer<LongFunction<CompletableFuture<?>>> registry,
-            IgniteSpinBusyLock busyLock
-    ) {
-        this.tableManager = tableManager;
-        this.schemaManager = schemaManager;
-
-        schemasVv = new IncrementalVersionedValue<>(registry, HashMap::new);
-        tablesVv = new IncrementalVersionedValue<>(registry, HashMap::new);
-        indicesVv = new IncrementalVersionedValue<>(registry, HashMap::new);
-        this.busyLock = busyLock;
-
-        calciteSchemaVv = new CompletableVersionedValue<>(() -> {
-            SchemaPlus newCalciteSchema = Frameworks.createRootSchema(false);
-            newCalciteSchema.add(DEFAULT_SCHEMA_NAME, new IgniteSchema(DEFAULT_SCHEMA_NAME));
-            return newCalciteSchema;
-        });
-
-        schemasVv.whenComplete((token, stringIgniteSchemaMap, throwable) -> {
-            if (!busyLock.enterBusy()) {
-                calciteSchemaVv.completeExceptionally(token, new IgniteInternalException(NODE_STOPPING_ERR, new NodeStoppingException()));
-
-                return;
-            }
-            try {
-                if (throwable != null) {
-                    calciteSchemaVv.completeExceptionally(
-                            token,
-                            new IgniteInternalException(
-                                    INTERNAL_ERR, "Couldn't evaluate sql schemas for causality token: " + token, throwable)
-                    );
-
-                    return;
-                }
-
-                SchemaPlus newCalciteSchema = rebuild(stringIgniteSchemaMap);
-
-                listeners.forEach(SchemaUpdateListener::onSchemaUpdated);
-
-                calciteSchemaVv.complete(token, newCalciteSchema);
-            } finally {
-                busyLock.leaveBusy();
-            }
-        });
-    }
-
-    /** 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();
-
-        SchemaPlus schemaPlus = calciteSchemaVv.latest();
-
-        return schema != null ? schemaPlus.getSubSchema(schema) : schemaPlus.getSubSchema(DEFAULT_SCHEMA_NAME);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    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<Void> schemaReadyFuture(long version) {
-        if (!busyLock.enterBusy()) {
-            throw new IgniteInternalException(NODE_STOPPING_ERR, new NodeStoppingException());
-        }
-        try {
-            if (version == IgniteSchema.INITIAL_VERSION) {
-                return completedFuture(null);
-            }
-
-            CompletableFuture<Void> lastSchemaFut;
-
-            try {
-                lastSchemaFut = calciteSchemaVv.get(version).thenAccept(ignore -> {});
-            } catch (OutdatedTokenException e) {
-                return completedFuture(null);
-            }
-
-            return lastSchemaFut;
-        } finally {
-            busyLock.leaveBusy();
-        }
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteTable tableById(int id) {
-        if (!busyLock.enterBusy()) {
-            throw new IgniteInternalException(NODE_STOPPING_ERR, new NodeStoppingException());
-        }
-        try {
-            IgniteTable table = tablesVv.latest().get(id);
-
-            if (table == null) {
-                throw new IgniteInternalException(INTERNAL_ERR,
-                        format("Table not found [tableId={}]", id));
-            }
-
-            return table;
-        } finally {
-            busyLock.leaveBusy();
-        }
-    }
-
-    public void registerListener(SchemaUpdateListener listener) {
-        listeners.add(listener);
-    }
-
-    /**
-     * OnSqlTypeCreated.
-     * TODO Documentation https://issues.apache.org/jira/browse/IGNITE-15859
-     */
-    public CompletableFuture<?> onTableCreated(String schemaName, int tableId, long causalityToken) {
-        if (!busyLock.enterBusy()) {
-            return failedFuture(new IgniteInternalException(NODE_STOPPING_ERR, new NodeStoppingException()));
-        }
-
-        try {
-            pkIdxReady.computeIfAbsent(tableId, k -> new CompletableFuture<>());
-
-            CompletableFuture<Map<Integer, IgniteTable>> updatedTables = tablesVv.update(causalityToken, (tables, e) ->
-                    inBusyLock(busyLock, () -> {
-                        if (e != null) {
-                            return failedFuture(e);
-                        }
-
-                        return tableManager.tableAsync(causalityToken, tableId)
-                                .thenCompose(table -> convert(causalityToken, table))
-                                .thenApply(igniteTable -> {
-                                    Map<Integer, IgniteTable> resTbls = new HashMap<>(tables);
-
-                                    IgniteTable oldTable = resTbls.put(igniteTable.id(), igniteTable);
-
-                                    // looks like this is UPDATE operation
-                                    if (oldTable != null) {
-                                        for (var index : oldTable.indexes().values()) {
-                                            igniteTable.addIndex(index);
-                                        }
-                                    }
-
-                                    return resTbls;
-                                });
-                    })
-            );
-
-            schemasVv.update(causalityToken, (schemas, e) -> inBusyLock(busyLock, () -> {
-                if (e != null) {
-                    return failedFuture(e);
-                }
-
-                return updatedTables.thenApply(tables -> {
-                    IgniteTable igniteTable = tables.get(tableId);
-
-                    Map<String, IgniteSchema> res = new HashMap<>(schemas);
-
-                    IgniteSchema schema = res.compute(schemaName,
-                            (k, v) -> v == null ? new IgniteSchema(schemaName, causalityToken) : IgniteSchema.copy(v, causalityToken));
-
-                    schema.addTable(igniteTable);
-
-                    return res;
-                });
-            }));
-
-            // calciteSchemaVv depends on all other Versioned Values and is completed last.
-            return calciteSchemaVv.get(causalityToken);
-        } finally {
-            busyLock.leaveBusy();
-        }
-    }
-
-    /**
-     * OnSqlTypeUpdated.
-     * TODO Documentation https://issues.apache.org/jira/browse/IGNITE-15859
-     */
-    public CompletableFuture<?> onTableUpdated(String schemaName, int tableId, long causalityToken) {
-        return onTableCreated(schemaName, tableId, causalityToken);
-    }
-
-    /**
-     * OnSqlTypeDropped.
-     * TODO Documentation https://issues.apache.org/jira/browse/IGNITE-15859
-     */
-    public CompletableFuture<?> onTableDropped(String schemaName, int tableId, long causalityToken) {
-        if (!busyLock.enterBusy()) {
-            return failedFuture(new IgniteInternalException(NODE_STOPPING_ERR, new NodeStoppingException()));
-        }
-
-        try {
-            CompletableFuture<IgniteTable> removedTableFuture = new CompletableFuture<>();
-
-            tablesVv.update(causalityToken, (tables, e) -> inBusyLock(busyLock, () -> {
-                if (e != null) {
-                    removedTableFuture.completeExceptionally(e);
-
-                    return failedFuture(e);
-                }
-
-                Map<Integer, IgniteTable> resTbls = new HashMap<>(tables);
-
-                IgniteTable removedTable = resTbls.remove(tableId);
-
-                removedTableFuture.complete(removedTable);
-
-                return completedFuture(resTbls);
-            }));
-
-            schemasVv.update(causalityToken, (schemas, e) -> inBusyLock(busyLock, () -> {
-                if (e != null) {
-                    return failedFuture(e);
-                }
-
-                return removedTableFuture.thenApply(table -> {
-                    if (table == null) {
-                        return schemas;
-                    }
-
-                    Map<String, IgniteSchema> res = new HashMap<>(schemas);
-
-                    IgniteSchema schema = res.compute(schemaName,
-                            (k, v) -> v == null ? new IgniteSchema(schemaName, causalityToken) : IgniteSchema.copy(v, causalityToken));
-
-                    schema.removeTable(table.name());
-
-                    pkIdxReady.remove(table.id());
-
-                    return res;
-                });
-            }));
-
-            // calciteSchemaVv depends on all other Versioned Values and is completed last.
-            return calciteSchemaVv.get(causalityToken);
-        } finally {
-            busyLock.leaveBusy();
-        }
-    }
-
-    /**
-     * Rebuilds Calcite schemas.
-     *
-     * @param schemas Ignite schemas.
-     */
-    private SchemaPlus rebuild(Map<String, IgniteSchema> schemas) {
-        SchemaPlus newCalciteSchema = Frameworks.createRootSchema(false);
-
-        newCalciteSchema.add(DEFAULT_SCHEMA_NAME, new IgniteSchema(DEFAULT_SCHEMA_NAME));
-
-        schemas.forEach(newCalciteSchema::add);
-
-        return newCalciteSchema;
-    }
-
-    private CompletableFuture<IgniteTableImpl> convert(long causalityToken, TableImpl table) {
-        return schemaManager.schemaRegistry(causalityToken, table.tableId())
-                .thenApply(schemaRegistry -> inBusyLock(busyLock, () -> convert(table, schemaRegistry, causalityToken)));
-    }
-
-    private IgniteTableImpl convert(TableImpl table, SchemaRegistry schemaRegistry, long schemaVersion) {
-        SchemaDescriptor descriptor = schemaRegistry.schema();
-
-        List<ColumnDescriptor> colDescriptors = descriptor.columnNames().stream()
-                .map(descriptor::column)
-                .sorted(Comparator.comparingInt(Column::columnOrder))
-                .map(col -> new ColumnDescriptorImpl(
-                        col.name(),
-                        descriptor.isKeyColumn(col.schemaIndex()),
-                        col.nullable(),
-                        col.columnOrder(),
-                        col.schemaIndex(),
-                        col.type(),
-                        convertDefaultValueProvider(col.defaultValueProvider()),
-                        col::defaultValue
-                ))
-                .collect(Collectors.toList());
-
-        IntList colocationColumns = new IntArrayList();
-
-        for (Column column : descriptor.colocationColumns()) {
-            colocationColumns.add(column.columnOrder());
-        }
-
-        // TODO Use the actual zone ID after implementing https://issues.apache.org/jira/browse/IGNITE-18426.
-        IgniteDistribution distribution = IgniteDistributions.affinity(colocationColumns, table.tableId(), table.tableId());
-
-        InternalTable internalTable = table.internalTable();
-        DoubleSupplier rowCount = IgniteTableImpl.rowCountStatistic(internalTable);
-
-        return new IgniteTableImpl(
-                new TableDescriptorImpl(colDescriptors, distribution),
-                internalTable.tableId(),
-                internalTable.name(),
-                schemaRegistry.lastSchemaVersion(),
-                rowCount
-        );
-    }
-
-    private DefaultValueStrategy convertDefaultValueProvider(DefaultValueProvider defaultValueProvider) {
-        return defaultValueProvider.type() == Type.CONSTANT
-                ? DefaultValueStrategy.DEFAULT_CONSTANT
-                : DefaultValueStrategy.DEFAULT_COMPUTED;
-    }
-
-    /**
-     * Index created callback method register index in Calcite schema.
-     *
-     * @param tableId Table ID.
-     * @param indexId Index ID.
-     * @param causalityToken Causality token.
-     * @return Schema registration future.
-     */
-    public CompletableFuture<?> onIndexCreated(int tableId, int indexId, IndexDescriptor indexDescriptor, long causalityToken) {
-        if (!busyLock.enterBusy()) {
-            return failedFuture(new IgniteInternalException(NODE_STOPPING_ERR, new NodeStoppingException()));
-        }
-
-        try {
-            CompletableFuture<Map<Integer, IgniteIndex>> updatedIndices = indicesVv.update(causalityToken, (indices, e) ->
-                    inBusyLock(busyLock, () -> {
-                        if (e != null) {
-                            return failedFuture(e);
-                        }
-
-                        return tableManager.tableAsync(causalityToken, tableId).thenApply(table -> {
-                            var igniteIndex = new IgniteIndex(newIndex(table, indexId, indexDescriptor));
-
-                            Map<Integer, IgniteIndex> resIdxs = new HashMap<>(indices);
-
-                            resIdxs.put(indexId, igniteIndex);
-
-                            return resIdxs;
-                        });
-                    }));
-
-            CompletableFuture<Map<Integer, IgniteTable>> updatedTables = tablesVv.update(causalityToken, (tables, e) ->
-                    inBusyLock(busyLock, () -> {
-                        if (e != null) {
-                            return failedFuture(e);
-                        }
-
-                        return updatedIndices.thenApply(indices -> {
-                            IgniteIndex igniteIndex = indices.get(indexId);
-
-                            Map<Integer, IgniteTable> resTbls = new HashMap<>(tables);
-
-                            IgniteTable igniteTable = resTbls.computeIfPresent(tableId,
-                                    (k, v) -> IgniteTableImpl.copyOf((IgniteTableImpl) v));
-
-                            assert igniteTable != null : "Table " + tableId + " was not found";
-
-                            igniteTable.addIndex(igniteIndex);
-
-                            return resTbls;
-                        });
-                    }));
-
-            schemasVv.update(causalityToken, (schemas, e) -> inBusyLock(busyLock, () -> {
-                if (e != null) {
-                    return failedFuture(e);
-                }
-
-                return updatedTables.thenCombine(updatedIndices, (tables, indices) -> inBusyLock(busyLock, () -> {
-                    Map<String, IgniteSchema> res = new HashMap<>(schemas);
-
-                    IgniteSchema schema = res.compute(DEFAULT_SCHEMA_NAME,
-                            (k, v) -> v == null ? new IgniteSchema(k, causalityToken) : IgniteSchema.copy(v, causalityToken));
-
-                    schema.addTable(tables.get(tableId));
-
-                    schema.addIndex(indexId, indices.get(indexId));
-
-                    return res;
-                }));
-            }));
-
-            // this stub is necessary for observing pk index creation.
-            schemasVv.whenComplete((token, stringIgniteSchemaMap, throwable) -> {
-                CompletableFuture<?> pkFut = pkIdxReady.get(tableId);
-                // this listener is called repeatedly on node stop.
-                if (pkFut != null) {
-                    pkFut.complete(null);
-                }
-            });
-
-            return calciteSchemaVv.get(causalityToken);
-        } finally {
-            busyLock.leaveBusy();
-        }
-    }
-
-    private static Index<?> newIndex(TableImpl table, int indexId, IndexDescriptor descriptor) {
-        if (descriptor instanceof SortedIndexDescriptor) {
-            return new SortedIndexImpl(indexId, table.internalTable(), (SortedIndexDescriptor) descriptor);
-        } else {
-            return new HashIndex(indexId, table.internalTable(), descriptor);
-        }
-    }
-
-    /**
-     * Index dropped callback method deregisters index from Calcite schema.
-     *
-     * @param schemaName Schema name.
-     * @param indexId Index id.
-     * @param causalityToken Causality token.
-     * @return Schema registration future.
-     */
-    public CompletableFuture<?> onIndexDropped(String schemaName, int tableId, int indexId, long causalityToken) {
-        if (!busyLock.enterBusy()) {
-            return failedFuture(new IgniteInternalException(NODE_STOPPING_ERR, new NodeStoppingException()));
-        }
-
-        try {
-            CompletableFuture<IgniteIndex> removedIndexFuture = new CompletableFuture<>();
-
-            indicesVv.update(causalityToken, (indices, e) -> inBusyLock(busyLock, () -> {
-                if (e != null) {
-                    removedIndexFuture.completeExceptionally(e);
-
-                    return failedFuture(e);
-                }
-
-                Map<Integer, IgniteIndex> resIdxs = new HashMap<>(indices);
-
-                IgniteIndex rmvIdx = resIdxs.remove(indexId);
-
-                removedIndexFuture.complete(rmvIdx);
-
-                return completedFuture(resIdxs);
-            }));
-
-            CompletableFuture<Map<Integer, IgniteTable>> updatedTables = tablesVv.update(causalityToken, (tables, e) ->
-                    inBusyLock(busyLock, () -> {
-                        if (e != null) {
-                            return failedFuture(e);
-                        }
-
-                        Map<Integer, IgniteTable> resTbls = new HashMap<>(tables);
-
-                        IgniteTable table = resTbls.computeIfPresent(tableId, (k, v) -> IgniteTableImpl.copyOf((IgniteTableImpl) v));
-
-                        if (table == null) {
-                            return completedFuture(resTbls);
-                        } else {
-                            return removedIndexFuture.thenApply(rmvIndex -> {
-                                table.removeIndex(rmvIndex.name());
-
-                                return resTbls;
-                            });
-                        }
-                    }));
-
-            schemasVv.update(causalityToken, (schemas, e) -> inBusyLock(busyLock, () -> {
-                if (e != null) {
-                    return failedFuture(e);
-                }
-
-                Map<String, IgniteSchema> res = new HashMap<>(schemas);
-
-                IgniteSchema schema = res.compute(schemaName,
-                        (k, v) -> v == null ? new IgniteSchema(schemaName, causalityToken) : IgniteSchema.copy(v, causalityToken));
-
-                schema.removeIndex(indexId);
-
-                return updatedTables.thenApply(tables -> {
-                    IgniteTable table = tables.get(tableId);
-
-                    if (table != null) {
-                        schema.addTable(tables.get(tableId));
-                    }
-
-                    return res;
-                });
-            }));
-
-            return calciteSchemaVv.get(causalityToken);
-        } finally {
-            busyLock.leaveBusy();
-        }
-    }
-}
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/BaseQueryContext.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/BaseQueryContext.java
index c6a8cc0743..2c5d48ce64 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/BaseQueryContext.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/BaseQueryContext.java
@@ -221,7 +221,7 @@ public final class BaseQueryContext extends AbstractQueryContext {
         return rexBuilder;
     }
 
-    public long schemaVersion() {
+    public int schemaVersion() {
         return Objects.requireNonNull(schema().unwrap(IgniteSchema.class)).schemaVersion();
     }
 
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 4a5a0a6a1c..1f9236fa41 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.schemaReadyFuture(isA(long.class))).thenReturn(CompletableFuture.completedFuture(null));
+        when(schemaManagerMock.schemaReadyFuture(isA(int.class))).thenReturn(CompletableFuture.completedFuture(null));
 
         TestExecutableTableRegistry executableTableRegistry = new TestExecutableTableRegistry();
         executableTableRegistry.setColocatioGroupProvider((tableId) -> {
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
deleted file mode 100644
index c74ab32423..0000000000
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/schema/SqlSchemaManagerTest.java
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * 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.internal.sql.engine.exec.schema;
-
-import static java.util.concurrent.CompletableFuture.allOf;
-import static java.util.concurrent.CompletableFuture.completedFuture;
-import static org.apache.ignite.internal.testframework.IgniteTestUtils.await;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertInstanceOf;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNotSame;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicLong;
-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.catalog.CatalogService;
-import org.apache.ignite.internal.index.IndexDescriptor;
-import org.apache.ignite.internal.schema.Column;
-import org.apache.ignite.internal.schema.NativeTypes;
-import org.apache.ignite.internal.schema.SchemaDescriptor;
-import org.apache.ignite.internal.schema.SchemaManager;
-import org.apache.ignite.internal.schema.registry.SchemaRegistryImpl;
-import org.apache.ignite.internal.sql.engine.planner.AbstractPlannerTest.TestHashIndex;
-import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
-import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
-import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
-import org.apache.ignite.internal.sql.engine.schema.IgniteTableImpl;
-import org.apache.ignite.internal.sql.engine.schema.SqlSchemaManagerImpl;
-import org.apache.ignite.internal.table.InternalTable;
-import org.apache.ignite.internal.table.TableImpl;
-import org.apache.ignite.internal.table.distributed.TableManager;
-import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
-import org.apache.ignite.internal.util.IgniteSpinBusyLock;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-/**
- * Tests to verify {@link SqlSchemaManagerImpl}.
- */
-@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;
-
-    private final SchemaDescriptor schemaDescriptor = new SchemaDescriptor(
-            1,
-            new Column[]{new Column(0, "ID", NativeTypes.INT64, false)},
-            new Column[]{new Column(1, "VAL", NativeTypes.INT64, false)}
-    );
-
-    @Mock
-    private TableManager tableManager;
-
-    @Mock
-    private SchemaManager schemaManager;
-
-    @Mock
-    private TableImpl table;
-
-    @Mock
-    private SchemaRegistryImpl schemaRegistry;
-
-    private SqlSchemaManagerImpl sqlSchemaManager;
-
-    private TestRevisionRegister testRevisionRegister;
-
-    /** Busy lock for stop synchronisation. */
-    private final IgniteSpinBusyLock busyLock = new IgniteSpinBusyLock();
-
-    @BeforeEach
-    public void setup() {
-        Mockito.reset(tableManager);
-
-        when(tableManager.tableAsync(anyLong(), eq(tableId))).thenReturn(completedFuture(table));
-
-        testRevisionRegister = new TestRevisionRegister();
-
-        sqlSchemaManager = new SqlSchemaManagerImpl(
-                tableManager,
-                schemaManager,
-                testRevisionRegister,
-                busyLock
-        );
-
-        testRevisionRegister.moveForward();
-    }
-
-    @Test
-    public void testOnTableDroppedHandler() {
-        InternalTable mock = mock(InternalTable.class);
-        when(mock.tableId()).thenReturn(tableId);
-        when(mock.name()).thenReturn("T");
-
-        when(table.internalTable()).thenReturn(mock);
-        when(table.tableId()).thenReturn(tableId);
-        when(schemaRegistry.schema()).thenReturn(schemaDescriptor);
-        when(schemaRegistry.lastSchemaVersion()).thenReturn(schemaDescriptor.version());
-
-        when(schemaManager.schemaRegistry(anyLong(), anyInt())).thenReturn(completedFuture(schemaRegistry));
-
-        sqlSchemaManager.onTableCreated(SCHEMA_NAME, tableId, testRevisionRegister.actualToken() + 1);
-        testRevisionRegister.moveForward();
-
-        TestHashIndex testHashIndex = TestHashIndex.create(List.of("ID"), "pk_idx", tableId);
-
-        sqlSchemaManager.onIndexCreated(
-                testHashIndex.tableId(),
-                testHashIndex.id(),
-                testHashIndex.descriptor(),
-                testRevisionRegister.actualToken() + 1
-        );
-
-        testRevisionRegister.moveForward();
-
-        Table schemaTable = sqlSchemaManager.latestSchema(SCHEMA_NAME).getTable("T");
-
-        assertNotNull(schemaTable);
-        IgniteTableImpl igniteTable = assertInstanceOf(IgniteTableImpl.class, schemaTable);
-        assertEquals(tableId, igniteTable.id());
-
-        sqlSchemaManager.onTableDropped(SCHEMA_NAME, tableId, testRevisionRegister.actualToken() + 1);
-        testRevisionRegister.moveForward();
-
-        assertNull(sqlSchemaManager.latestSchema(SCHEMA_NAME).getTable("T"));
-    }
-
-    @Test
-    public void testIndexEventHandler() {
-        InternalTable mock = mock(InternalTable.class);
-        when(mock.tableId()).thenReturn(tableId);
-        when(mock.name()).thenReturn("T");
-
-        when(table.internalTable()).thenReturn(mock);
-        when(table.tableId()).thenReturn(tableId);
-        when(schemaRegistry.schema()).thenReturn(schemaDescriptor);
-        when(schemaRegistry.lastSchemaVersion()).thenReturn(schemaDescriptor.version());
-        when(schemaManager.schemaRegistry(anyLong(), anyInt())).thenReturn(completedFuture(schemaRegistry));
-
-        sqlSchemaManager.onTableCreated(SCHEMA_NAME, tableId, testRevisionRegister.actualToken() + 1);
-        testRevisionRegister.moveForward();
-
-        TestHashIndex testHashIndex = TestHashIndex.create(List.of("ID"), "pk_idx", tableId);
-
-        sqlSchemaManager.onIndexCreated(
-                testHashIndex.tableId(),
-                testHashIndex.id(),
-                testHashIndex.descriptor(),
-                testRevisionRegister.actualToken() + 1
-        );
-
-        testRevisionRegister.moveForward();
-
-        assertEquals(1, ((IgniteTableImpl) sqlSchemaManager.latestSchema(SCHEMA_NAME).getTable("T")).indexes().size());
-
-        IndexDescriptor descMock = mock(IndexDescriptor.class);
-        when(descMock.columns()).thenReturn(List.of());
-        when(descMock.name()).thenReturn("PUBLIC.I");
-
-        sqlSchemaManager.onIndexCreated(tableId, indexId, descMock, testRevisionRegister.actualToken() + 1);
-
-        testRevisionRegister.moveForward();
-
-        IgniteSchema schema = sqlSchemaManager.latestSchema(SCHEMA_NAME).unwrap(IgniteSchema.class);
-        Table schemaTable = schema.getTable("T");
-        IgniteIndex igniteIndex = schema.index(indexId);
-
-        assertNotNull(igniteIndex);
-
-        IgniteTableImpl igniteTable = assertInstanceOf(IgniteTableImpl.class, schemaTable);
-
-        assertEquals(igniteTable.id(), igniteIndex.tableId());
-        assertSame(igniteIndex, igniteTable.indexes().get("PUBLIC.I"));
-
-        sqlSchemaManager.onIndexDropped(SCHEMA_NAME, igniteTable.id(), indexId, testRevisionRegister.actualToken() + 1);
-        testRevisionRegister.moveForward();
-
-        assertNull(sqlSchemaManager.latestSchema(SCHEMA_NAME).unwrap(IgniteSchema.class).index(indexId));
-
-        verifyNoMoreInteractions(tableManager);
-    }
-
-
-    @Test
-    public void testIndexEventsProcessed() {
-        InternalTable mock = mock(InternalTable.class);
-        when(mock.tableId()).thenReturn(tableId);
-        when(mock.name()).thenReturn("T");
-
-        when(table.internalTable()).thenReturn(mock);
-        when(table.tableId()).thenReturn(tableId);
-        when(schemaRegistry.schema()).thenReturn(schemaDescriptor);
-        when(schemaRegistry.lastSchemaVersion()).thenReturn(schemaDescriptor.version());
-        when(schemaManager.schemaRegistry(anyLong(), anyInt())).thenReturn(completedFuture(schemaRegistry));
-
-        sqlSchemaManager.onTableCreated(SCHEMA_NAME, table.tableId(), testRevisionRegister.actualToken() + 1);
-        testRevisionRegister.moveForward();
-
-        TestHashIndex testHashIndex = TestHashIndex.create(List.of("ID"), "pk_idx", tableId);
-
-        sqlSchemaManager.onIndexCreated(
-                testHashIndex.tableId(),
-                testHashIndex.id(),
-                testHashIndex.descriptor(),
-                testRevisionRegister.actualToken() + 1
-        );
-
-        testRevisionRegister.moveForward();
-
-        String idxName = "I";
-
-        IndexDescriptor descMock = mock(IndexDescriptor.class);
-        when(descMock.columns()).thenReturn(List.of());
-        when(descMock.name()).thenReturn(idxName);
-
-        {
-            SchemaPlus schema1 = sqlSchemaManager.latestSchema(SCHEMA_NAME);
-
-            sqlSchemaManager.onIndexCreated(tableId, indexId, descMock, testRevisionRegister.actualToken() + 1);
-            testRevisionRegister.moveForward();
-
-            SchemaPlus schema2 = sqlSchemaManager.latestSchema(SCHEMA_NAME);
-
-            // Validate schema snapshot.
-            assertNotSame(schema1, schema2);
-            assertNotSame(schema1.getTable("T"), schema2.getTable("T"));
-
-            assertNull(schema1.unwrap(IgniteSchema.class).index(indexId));
-            assertNotNull(schema2.unwrap(IgniteSchema.class).index(indexId));
-
-            assertNull(((IgniteTable) schema1.getTable("T")).getIndex(idxName));
-            assertNotNull(((IgniteTable) schema2.getTable("T")).getIndex(idxName));
-        }
-        {
-            sqlSchemaManager.onIndexDropped(SCHEMA_NAME, table.tableId(), indexId, testRevisionRegister.actualToken() + 1);
-            SchemaPlus schema1 = sqlSchemaManager.latestSchema(SCHEMA_NAME);
-            testRevisionRegister.moveForward();
-
-            SchemaPlus schema2 = sqlSchemaManager.latestSchema(SCHEMA_NAME);
-
-            // Validate schema snapshot.
-            assertNotSame(schema1, schema2);
-            assertNotSame(schema1.getTable("T"), schema2.getTable("T"));
-
-            assertNotNull(schema1.unwrap(IgniteSchema.class).index(indexId));
-            assertNull(schema2.unwrap(IgniteSchema.class).index(indexId));
-
-            assertNull(((IgniteTable) schema2.getTable("T")).getIndex(idxName));
-            assertNotNull(((IgniteTable) schema1.getTable("T")).getIndex(idxName));
-        }
-
-        verifyNoMoreInteractions(tableManager);
-    }
-
-    /**
-     * Test revision register.
-     */
-    private static class TestRevisionRegister implements Consumer<LongFunction<CompletableFuture<?>>> {
-        AtomicLong token = new AtomicLong(-1);
-
-        /** Revision consumer. */
-        private LongFunction<CompletableFuture<?>> moveRevision;
-
-        /**
-         * Moves forward token.
-         */
-        void moveForward() {
-            await(moveRevision.apply(token.incrementAndGet()));
-        }
-
-        /**
-         * Gets an actual token.
-         *
-         * @return Actual token.
-         */
-        long actualToken() {
-            return token.get();
-        }
-
-        /** {@inheritDoc} */
-        @Override
-        public void accept(LongFunction<CompletableFuture<?>> function) {
-            if (moveRevision == null) {
-                moveRevision = function;
-            } else {
-                LongFunction<CompletableFuture<?>> old = moveRevision;
-
-                moveRevision = rev -> allOf(
-                        old.apply(rev),
-                        function.apply(rev)
-                );
-            }
-        }
-    }
-}
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 e497e2564f..6c3448ba52 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
@@ -82,7 +82,7 @@ public class PredefinedSchemaManager implements SqlSchemaManager {
 
     /** {@inheritDoc} */
     @Override
-    public CompletableFuture<Void> schemaReadyFuture(long version) {
+    public CompletableFuture<Void> schemaReadyFuture(int version) {
         return completedFuture(null);
     }
 


[ignite-3] 01/03: Fix compilation for feature branch.

Posted by am...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

amashenkov pushed a commit to branch ignite-19497
in repository https://gitbox.apache.org/repos/asf/ignite-3.git

commit ee9b4bbd20c76da8a52e7ad89b93d02cd5f33b77
Author: amashenkov <an...@gmail.com>
AuthorDate: Mon Aug 14 17:16:24 2023 +0300

    Fix compilation for feature branch.
---
 .../java/org/apache/ignite/internal/sql/api/ItSqlSynchronousApiTest.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/api/ItSqlSynchronousApiTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/api/ItSqlSynchronousApiTest.java
index 1d9f4a6a3f..80e804f437 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/api/ItSqlSynchronousApiTest.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/api/ItSqlSynchronousApiTest.java
@@ -61,6 +61,7 @@ import org.apache.ignite.sql.SqlRow;
 import org.apache.ignite.table.Table;
 import org.apache.ignite.tx.Transaction;
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInfo;
 


[ignite-3] 03/03: Switch to schema objects based on catalog.

Posted by am...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

amashenkov pushed a commit to branch ignite-19497
in repository https://gitbox.apache.org/repos/asf/ignite-3.git

commit 8c3867fbcb2144c6844ea6e3b08d1164fc8f7bf1
Author: amashenkov <an...@gmail.com>
AuthorDate: Mon Aug 14 23:16:55 2023 +0300

    Switch to schema objects based on catalog.
---
 .../runner/app/PlatformTestNodeRunner.java         |  16 +-
 .../ignite/internal/sql/api/ItCommonApiTest.java   |   7 -
 .../ignite/internal/sql/engine/ItDmlTest.java      |   2 +-
 .../internal/sql/engine/exec/ExecutableTable.java  |   6 +
 .../sql/engine/exec/ExecutableTableRegistry.java   |   6 +-
 .../engine/exec/ExecutableTableRegistryImpl.java   |  41 +++-
 .../exec/ExecutionDependencyResolverImpl.java      |   4 +-
 .../sql/engine/exec/ExecutionServiceImpl.java      |  38 ++--
 .../sql/engine/exec/LogicalRelImplementor.java     |   8 +-
 .../sql/engine/exec/ResolvedDependencies.java      |   6 +
 .../sql/engine/exec/TableRowConverterImpl.java     |  24 ++-
 .../sql/engine/exec/UpdatableTableImpl.java        |   4 +-
 .../sql/engine/exec/rel/IndexScanNode.java         |  12 +-
 .../internal/sql/engine/prepare/CacheKey.java      |   6 +-
 .../sql/engine/prepare/PrepareServiceImpl.java     |   2 +-
 .../engine/rel/logical/IgniteLogicalIndexScan.java |   5 +-
 .../sql/engine/rule/LogicalScanConverterRule.java  |   5 +-
 .../sql/engine/rule/logical/ExposeIndexRule.java   |   6 +-
 .../engine/rule/logical/LogicalOrToUnionRule.java  |   4 +-
 .../sql/engine/schema/CatalogColumnDescriptor.java |   6 -
 .../sql/engine/schema/CatalogSqlSchemaManager.java |  40 ++--
 .../sql/engine/schema/ColumnDescriptor.java        |   3 -
 .../sql/engine/schema/ColumnDescriptorImpl.java    |  11 --
 .../sql/engine/schema/IgniteCatalogSchema.java     |  58 ------
 .../internal/sql/engine/schema/IgniteIndex.java    | 206 +++++++++++++--------
 .../internal/sql/engine/schema/IgniteSchema.java   | 136 ++++----------
 .../sql/engine/schema/IgniteSchemaIndex.java       | 143 --------------
 .../sql/engine/schema/IgniteSchemaTable.java       |  50 +----
 .../internal/sql/engine/schema/IgniteTable.java    |  47 -----
 .../sql/engine/schema/SqlSchemaManager.java        |   8 -
 .../sql/engine/schema/TableDescriptorImpl.java     |   1 -
 .../internal/sql/engine/trait/TraitUtils.java      |  16 --
 .../internal/sql/engine/util/BaseQueryContext.java |   2 +-
 .../sql/engine/util/HashFunctionFactoryImpl.java   |  12 +-
 .../exec/ExecutableTableRegistrySelfTest.java      |   2 +-
 .../exec/ExecutionDependencyResolverSelfTest.java  |  17 +-
 .../sql/engine/exec/ExecutionServiceImplTest.java  |  21 +--
 .../engine/exec/TestExecutableTableRegistry.java   |   7 +-
 .../exec/rel/IndexScanNodeExecutionTest.java       | 102 +++++-----
 .../engine/framework/PredefinedSchemaManager.java  |   6 -
 .../sql/engine/framework/TestBuilders.java         |  69 ++++---
 .../internal/sql/engine/framework/TestIndex.java   |  51 ++---
 .../internal/sql/engine/framework/TestNode.java    |  14 +-
 .../internal/sql/engine/framework/TestTable.java   |  55 ++----
 .../sql/engine/planner/AbstractPlannerTest.java    |  26 +--
 .../planner/IndexSearchBoundsPlannerTest.java      |   5 -
 .../engine/planner/JoinWithUsingPlannerTest.java   |  11 --
 .../sql/engine/prepare/TypeCoercionTest.java       |  28 ---
 .../engine/schema/CatalogSqlSchemaManagerTest.java |  32 ++--
 .../internal/sql/engine/util/StatementChecker.java |  22 +--
 .../storage/index/AbstractIndexStorageTest.java    |   4 +-
 51 files changed, 519 insertions(+), 894 deletions(-)

diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/PlatformTestNodeRunner.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/PlatformTestNodeRunner.java
index 8afecc4ad1..aae40c10e2 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/PlatformTestNodeRunner.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/PlatformTestNodeRunner.java
@@ -337,7 +337,7 @@ public class PlatformTestNodeRunner {
                 .tableName(TABLE_NAME_ALL_COLUMNS)
                 .columns(List.of(
                         ColumnParams.builder().name(keyCol).type(org.apache.ignite.sql.ColumnType.INT64).build(),
-                        ColumnParams.builder().name("STR").type(org.apache.ignite.sql.ColumnType.STRING).length(0).nullable(true).build(),
+                        ColumnParams.builder().name("STR").type(org.apache.ignite.sql.ColumnType.STRING).nullable(true).build(),
                         ColumnParams.builder().name("INT8").type(org.apache.ignite.sql.ColumnType.INT8).nullable(true).build(),
                         ColumnParams.builder().name("INT16").type(org.apache.ignite.sql.ColumnType.INT16).nullable(true).build(),
                         ColumnParams.builder().name("INT32").type(org.apache.ignite.sql.ColumnType.INT32).nullable(true).build(),
@@ -360,7 +360,7 @@ public class PlatformTestNodeRunner {
                                 .nullable(true).build(),
                         ColumnParams.builder().name("TIMESTAMP2").type(org.apache.ignite.sql.ColumnType.DATETIME).precision(4)
                                 .nullable(true).build(),
-                        ColumnParams.builder().name("BLOB").type(org.apache.ignite.sql.ColumnType.BYTE_ARRAY).length(0).nullable(true)
+                        ColumnParams.builder().name("BLOB").type(org.apache.ignite.sql.ColumnType.BYTE_ARRAY).nullable(true)
                                 .build(),
                         ColumnParams.builder().name("DECIMAL").type(org.apache.ignite.sql.ColumnType.DECIMAL).precision(19).scale(3)
                                 .nullable(true).build()
@@ -402,7 +402,7 @@ public class PlatformTestNodeRunner {
                 .tableName(TABLE_NAME_ALL_COLUMNS_SQL)
                 .columns(List.of(
                         ColumnParams.builder().name(keyCol).type(org.apache.ignite.sql.ColumnType.INT64).build(),
-                        ColumnParams.builder().name("STR").type(org.apache.ignite.sql.ColumnType.STRING).length(0).nullable(true).build(),
+                        ColumnParams.builder().name("STR").type(org.apache.ignite.sql.ColumnType.STRING).nullable(true).build(),
                         ColumnParams.builder().name("INT8").type(org.apache.ignite.sql.ColumnType.INT8).nullable(true).build(),
                         ColumnParams.builder().name("INT16").type(org.apache.ignite.sql.ColumnType.INT16).nullable(true).build(),
                         ColumnParams.builder().name("INT32").type(org.apache.ignite.sql.ColumnType.INT32).nullable(true).build(),
@@ -423,7 +423,7 @@ public class PlatformTestNodeRunner {
                                 .precision(maxTimePrecision).nullable(true).build(),
                         ColumnParams.builder().name("TIMESTAMP2").type(org.apache.ignite.sql.ColumnType.TIMESTAMP)
                                 .precision(maxTimePrecision).nullable(true).build(),
-                        ColumnParams.builder().name("BLOB").type(org.apache.ignite.sql.ColumnType.BYTE_ARRAY).length(0).nullable(true)
+                        ColumnParams.builder().name("BLOB").type(org.apache.ignite.sql.ColumnType.BYTE_ARRAY).nullable(true)
                                 .build(),
                         ColumnParams.builder().name("DECIMAL").type(org.apache.ignite.sql.ColumnType.DECIMAL).precision(19).scale(3)
                                 .nullable(true).build()
@@ -501,8 +501,8 @@ public class PlatformTestNodeRunner {
 
         createTwoColumnTable(
                 ignite,
-                ColumnParams.builder().name("KEY").type(org.apache.ignite.sql.ColumnType.STRING).length(0).build(),
-                ColumnParams.builder().name("VAL").type(org.apache.ignite.sql.ColumnType.STRING).length(0).nullable(true).build()
+                ColumnParams.builder().name("KEY").type(org.apache.ignite.sql.ColumnType.STRING).build(),
+                ColumnParams.builder().name("VAL").type(org.apache.ignite.sql.ColumnType.STRING).nullable(true).build()
         );
 
         createTwoColumnTable(
@@ -538,8 +538,8 @@ public class PlatformTestNodeRunner {
 
         createTwoColumnTable(
                 ignite,
-                ColumnParams.builder().name("KEY").type(org.apache.ignite.sql.ColumnType.BYTE_ARRAY).length(0).build(),
-                ColumnParams.builder().name("VAL").type(org.apache.ignite.sql.ColumnType.BYTE_ARRAY).length(0).nullable(true)
+                ColumnParams.builder().name("KEY").type(org.apache.ignite.sql.ColumnType.BYTE_ARRAY).build(),
+                ColumnParams.builder().name("VAL").type(org.apache.ignite.sql.ColumnType.BYTE_ARRAY).nullable(true)
                         .build()
         );
 
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 302b67daee..d67b384d25 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
@@ -35,7 +35,6 @@ import org.apache.ignite.Ignite;
 import org.apache.ignite.internal.sql.engine.ClusterPerClassIntegrationTest;
 import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
 import org.apache.ignite.internal.sql.engine.exec.ExecutionCancelledException;
-import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
 import org.apache.ignite.internal.sql.engine.schema.SqlSchemaManager;
 import org.apache.ignite.internal.testframework.IgniteTestUtils;
 import org.apache.ignite.internal.tx.InternalTransaction;
@@ -222,12 +221,6 @@ public class ItCommonApiTest extends ClusterPerClassIntegrationTest {
             return null;
         }
 
-        /** {@inheritDoc} */
-        @Override
-        public IgniteTable tableById(int id) {
-            throw new UnsupportedOperationException();
-        }
-
         /** {@inheritDoc} */
         @Override
         public CompletableFuture<Void> schemaReadyFuture(int version) {
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItDmlTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItDmlTest.java
index 6c9f9a6ed4..0b426924fe 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItDmlTest.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItDmlTest.java
@@ -370,7 +370,7 @@ public class ItDmlTest extends ClusterPerClassIntegrationTest {
         // With aliases, reference columns by table alias.
         sql("MERGE INTO test2 test1 USING test1 test2 ON test1.d = test2.b "
                 + "WHEN MATCHED THEN UPDATE SET a = test1.a + 1 "
-                + "WHEN NOT MATCHED THEN INSERT (a, d, e) VALUES (test2.a, test2.b, test2.c)");
+                + "WHEN NOT MATCHED THEN INSERT (k, a, d, e) VALUES (test2.k, test2.a, test2.b, test2.c)");
 
         assertQuery("SELECT * FROM test2").returns(1, 2, 0, "0").check();
     }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTable.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTable.java
index 68144cf693..4724347f2e 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTable.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTable.java
@@ -19,11 +19,17 @@ package org.apache.ignite.internal.sql.engine.exec;
 
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.sql.engine.metadata.ColocationGroup;
+import org.apache.ignite.internal.table.InternalTable;
 
 /**
  * Execution related APIs of a table.
  */
 public interface ExecutableTable {
+    /** TODO IGNITE-19499: Drop this hack to get underlying table. */
+    @Deprecated
+    default InternalTable internalTable() {
+        return null;
+    }
 
     /**
      * Returns read API.
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistry.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistry.java
index 36b8cb4eb6..9c6113fb1a 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistry.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistry.java
@@ -32,5 +32,9 @@ public interface ExecutableTableRegistry {
      * @param tableDescriptor Table descriptor.
      * @return An operation that returns executable table.
      */
-    CompletableFuture<ExecutableTable> getTable(int tableId, TableDescriptor tableDescriptor);
+    CompletableFuture<ExecutableTable> getTable(int schemaVersion, int tableId, TableDescriptor tableDescriptor);
+
+    // TODO IGNITE-19499 use tableId instead of name.
+    @Deprecated(forRemoval = true)
+    CompletableFuture<ExecutableTable> getTable(int schemaVersion, int tableId, String tableName, TableDescriptor tableDescriptor);
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistryImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistryImpl.java
index 64c6ffc52f..f2ed00c8ec 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistryImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistryImpl.java
@@ -50,7 +50,7 @@ public class ExecutableTableRegistryImpl implements ExecutableTableRegistry, Sch
 
     private final HybridClock clock;
 
-    final ConcurrentMap<Integer, CompletableFuture<ExecutableTable>> tableCache;
+    final ConcurrentMap<Long, CompletableFuture<ExecutableTable>> tableCache;
 
     /** Constructor. */
     public ExecutableTableRegistryImpl(TableManager tableManager, SchemaManager schemaManager,
@@ -62,13 +62,19 @@ public class ExecutableTableRegistryImpl implements ExecutableTableRegistry, Sch
         this.clock = clock;
         this.tableCache = Caffeine.newBuilder()
                 .maximumSize(cacheSize)
-                .<Integer, ExecutableTable>buildAsync().asMap();
+                .<Long, ExecutableTable>buildAsync().asMap();
     }
 
     /** {@inheritDoc} */
     @Override
-    public CompletableFuture<ExecutableTable> getTable(int tableId, TableDescriptor tableDescriptor) {
-        return tableCache.computeIfAbsent(tableId, (k) -> loadTable(k, tableDescriptor));
+    public CompletableFuture<ExecutableTable> getTable(int schemaVersion, int tableId, TableDescriptor tableDescriptor) {
+        return tableCache.computeIfAbsent(cacheKey(schemaVersion, tableId), (k) -> loadTable(tableId, tableDescriptor));
+    }
+
+    // TODO IGNITE-19499: Drop this temporal method to get table by name.
+    @Override
+    public CompletableFuture<ExecutableTable> getTable(int schemaVersion, int tableId, String tableName, TableDescriptor tableDescriptor) {
+        return tableCache.computeIfAbsent(cacheKey(schemaVersion, tableId), (k) -> loadTable(tableName, tableDescriptor));
     }
 
     /** {@inheritDoc} */
@@ -77,6 +83,22 @@ public class ExecutableTableRegistryImpl implements ExecutableTableRegistry, Sch
         tableCache.clear();
     }
 
+    private CompletableFuture<ExecutableTable> loadTable(String tableName, TableDescriptor tableDescriptor) {
+        return tableManager.tableAsyncInternal(tableName.toUpperCase())
+                .thenApply(table -> {
+                    InternalTable internalTable = table.internalTable();
+                    SchemaRegistry schemaRegistry = schemaManager.schemaRegistry(table.tableId());
+                    SchemaDescriptor schemaDescriptor = schemaRegistry.schema();
+                    TableRowConverter rowConverter = new TableRowConverterImpl(schemaRegistry, schemaDescriptor, tableDescriptor);
+                    ScannableTable scannableTable = new ScannableTableImpl(internalTable, rowConverter, tableDescriptor);
+
+                    UpdatableTableImpl updatableTable = new UpdatableTableImpl(table.tableId(), tableDescriptor, internalTable.partitions(),
+                            replicaService, clock, rowConverter, schemaDescriptor);
+
+                    return new ExecutableTableImpl(internalTable, scannableTable, updatableTable);
+                });
+    }
+
     private CompletableFuture<ExecutableTable> loadTable(int tableId, TableDescriptor tableDescriptor) {
         CompletableFuture<Map.Entry<InternalTable, SchemaRegistry>> f = tableManager.tableAsync(tableId)
                 .thenApply(table -> {
@@ -113,6 +135,13 @@ public class ExecutableTableRegistryImpl implements ExecutableTableRegistry, Sch
             this.updatableTable = updatableTable;
         }
 
+        // TODO IGNITE-19499: Drop this.
+        @Deprecated(forRemoval = true)
+        @Override
+        public InternalTable internalTable() {
+            return internalTable;
+        }
+
         /** {@inheritDoc} */
         @Override
         public ScannableTable scannableTable() {
@@ -138,4 +167,8 @@ public class ExecutableTableRegistryImpl implements ExecutableTableRegistry, Sch
             });
         }
     }
+
+    private static long cacheKey(int schemaVersion, int tableId) {
+        return (((long) schemaVersion) << 32) | (tableId & 0xffff_ffffL);
+    }
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverImpl.java
index e8bb7b7052..804f640860 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverImpl.java
@@ -81,8 +81,10 @@ public class ExecutionDependencyResolverImpl implements ExecutionDependencyResol
             private void resolveTable(IgniteTable igniteTable) {
                 int tableId = igniteTable.id();
                 TableDescriptor tableDescriptor = igniteTable.descriptor();
+                //TODO IGNITE-19499 Use id instead of name.
+                String tableName = igniteTable.name();
 
-                tableMap.computeIfAbsent(tableId, (id) -> registry.getTable(tableId, tableDescriptor));
+                tableMap.computeIfAbsent(tableId, (id) -> registry.getTable(schemaVersion, tableId, tableName, tableDescriptor));
             }
         };
 
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 0e63ecd898..c750c8383f 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
@@ -81,6 +81,7 @@ import org.apache.ignite.internal.sql.engine.rel.IgniteRel;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableModify;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan;
 import org.apache.ignite.internal.sql.engine.rel.SourceAwareIgniteRel;
+import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
 import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
 import org.apache.ignite.internal.sql.engine.schema.SqlSchemaManager;
 import org.apache.ignite.internal.sql.engine.util.BaseQueryContext;
@@ -172,7 +173,7 @@ public class ExecutionServiceImpl<RowT> implements ExecutionService, TopologyEve
                 dependencyResolver,
                 (ctx, deps) -> new LogicalRelImplementor<>(
                         ctx,
-                        new HashFunctionFactoryImpl<>(sqlSchemaManager, handler),
+                        new HashFunctionFactoryImpl<>(ctx.getRootSchema().unwrap(IgniteSchema.class), handler),
                         mailboxRegistry,
                         exchangeSrvc,
                         deps)
@@ -640,7 +641,11 @@ public class ExecutionServiceImpl<RowT> implements ExecutionService, TopologyEve
         }
 
         private AsyncCursor<List<Object>> execute(InternalTransaction tx, MultiStepPlan notMappedPlan) {
-            CompletableFuture<MultiStepPlan> f = mapFragments(notMappedPlan);
+            Iterable<IgniteRel> fragmentRoots = TransformingIterator.newIterable(notMappedPlan.fragments(), (f) -> f.root());
+
+            CompletableFuture<ResolvedDependencies> depsFut = dependencyResolver.resolveDependencies(fragmentRoots, ctx.schemaVersion());
+
+            CompletableFuture<MultiStepPlan> f = depsFut.thenCompose(deps -> mapFragments(notMappedPlan, deps));
 
             f.whenCompleteAsync((plan, mappingErr) -> {
                 if (mappingErr != null) {
@@ -660,7 +665,8 @@ public class ExecutionServiceImpl<RowT> implements ExecutionService, TopologyEve
                     // first let's enlist all tables to the transaction.
                     if (!tx.isReadOnly()) {
                         for (Fragment fragment : fragments) {
-                            enlistPartitions(fragment, tx);
+                            //TODO IGNITE-19499: Remove depsFut. Join is legal as future is already done.
+                            enlistPartitions(fragment, tx, depsFut.join());
                         }
                     }
 
@@ -777,7 +783,7 @@ public class ExecutionServiceImpl<RowT> implements ExecutionService, TopologyEve
             };
         }
 
-        private void enlistPartitions(Fragment fragment, InternalTransaction tx) {
+        private void enlistPartitions(Fragment fragment, InternalTransaction tx, ResolvedDependencies deps) {
             new IgniteRelShuttle() {
                 @Override
                 public IgniteRel visit(IgniteIndexScan rel) {
@@ -796,6 +802,9 @@ public class ExecutionServiceImpl<RowT> implements ExecutionService, TopologyEve
                 @Override
                 public IgniteRel visit(IgniteTableModify rel) {
                     int tableId = rel.getTable().unwrap(IgniteTable.class).id();
+
+                    // TODO IGNITE-19499 Remove rewriting tableId.
+                    tableId = deps.internalTable(tableId).tableId();
                     List<NodeWithTerm> assignments = fragment.mapping().updatingTableAssignments();
 
                     enlist(tableId, assignments);
@@ -822,6 +831,10 @@ public class ExecutionServiceImpl<RowT> implements ExecutionService, TopologyEve
 
                 private void enlist(SourceAwareIgniteRel rel) {
                     int tableId = rel.getTable().unwrap(IgniteTable.class).id();
+
+                    // TODO IGNITE-19499 Remove rewriting tableId.
+                    tableId = deps.internalTable(tableId).tableId();
+
                     List<NodeWithTerm> assignments = fragment.mapping().findGroup(rel.sourceId()).assignments().stream()
                             .map(l -> l.get(0))
                             .collect(Collectors.toList());
@@ -831,19 +844,12 @@ public class ExecutionServiceImpl<RowT> implements ExecutionService, TopologyEve
             }.visit(fragment.root());
         }
 
-        private CompletableFuture<MultiStepPlan> mapFragments(MultiStepPlan plan) {
-            Iterable<IgniteRel> fragments = TransformingIterator.newIterable(plan.fragments(), (f) -> f.root());
-
-            CompletableFuture<ResolvedDependencies> fut = dependencyResolver.resolveDependencies(fragments,
-                    ctx.schemaVersion());
+        private CompletableFuture<MultiStepPlan> mapFragments(MultiStepPlan plan, ResolvedDependencies deps) {
+            return fetchColocationGroups(deps).thenApply(colocationGroups -> {
+                MappingQueryContext mappingCtx = new MappingQueryContext(localNode.name(), mappingSrvc);
+                List<Fragment> mappedFragments = FragmentMapping.mapFragments(mappingCtx, plan.fragments(), colocationGroups);
 
-            return fut.thenCompose(deps -> {
-                return fetchColocationGroups(deps).thenApply(colocationGroups -> {
-                    MappingQueryContext mappingCtx = new MappingQueryContext(localNode.name(), mappingSrvc);
-                    List<Fragment> mappedFragments = FragmentMapping.mapFragments(mappingCtx, plan.fragments(), colocationGroups);
-
-                    return plan.replaceFragments(mappedFragments);
-                });
+                return plan.replaceFragments(mappedFragments);
             });
         }
 
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/LogicalRelImplementor.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/LogicalRelImplementor.java
index 832ac0d4be..5f1594b957 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/LogicalRelImplementor.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/LogicalRelImplementor.java
@@ -332,7 +332,7 @@ public class LogicalRelImplementor<RowT> implements IgniteRelVisitor<Node<RowT>>
         RelDataType rowType = tbl.getRowType(typeFactory, requiredColumns);
         ScannableTable scannableTable = resolvedDependencies.scannableTable(tbl.id());
 
-        IgniteIndex idx = tbl.getIndex(rel.indexName());
+        IgniteIndex idx = tbl.indexes().get(rel.indexName());
 
         List<SearchBounds> searchBounds = rel.searchBounds();
         RexNode condition = rel.condition();
@@ -346,11 +346,11 @@ public class LogicalRelImplementor<RowT> implements IgniteRelVisitor<Node<RowT>>
         if (searchBounds != null) {
             Comparator<RowT> searchRowComparator = null;
 
-            if (idx.collations() != null) {
-                searchRowComparator = expressionFactory.comparator(TraitUtils.createCollation(idx.collations()));
+            if (idx.type() == Type.SORTED) {
+                searchRowComparator = expressionFactory.comparator(IgniteIndex.deriveCollations(idx, tbl.descriptor().columnsCount()));
             }
 
-            ranges = expressionFactory.ranges(searchBounds, idx.getRowType(typeFactory, tbl.descriptor()), searchRowComparator);
+            ranges = expressionFactory.ranges(searchBounds, idx.rowType(typeFactory, tbl.descriptor()), searchRowComparator);
         }
 
         RelCollation outputCollation = rel.collation();
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ResolvedDependencies.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ResolvedDependencies.java
index cb5f9c4507..251c36bd95 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ResolvedDependencies.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/ResolvedDependencies.java
@@ -21,6 +21,7 @@ import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.sql.engine.metadata.ColocationGroup;
+import org.apache.ignite.internal.table.InternalTable;
 
 /**
  * Provides access to resolved dependencies.
@@ -58,6 +59,11 @@ public class ResolvedDependencies {
         return executableTable.fetchColocationGroup();
     }
 
+    /** TODO IGNITE-19499: Drop temporal method. */
+    public InternalTable internalTable(int tableId) {
+        return getTable(tableId).internalTable();
+    }
+
     public Set<Integer> tableIds() {
         return tableMap.keySet();
     }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/TableRowConverterImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/TableRowConverterImpl.java
index dc81c12c76..20cf38eb6c 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/TableRowConverterImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/TableRowConverterImpl.java
@@ -19,6 +19,7 @@ package org.apache.ignite.internal.sql.engine.exec;
 
 import java.util.BitSet;
 import org.apache.ignite.internal.schema.BinaryRow;
+import org.apache.ignite.internal.schema.Column;
 import org.apache.ignite.internal.schema.SchemaDescriptor;
 import org.apache.ignite.internal.schema.SchemaRegistry;
 import org.apache.ignite.internal.schema.row.Row;
@@ -36,13 +37,20 @@ public class TableRowConverterImpl implements TableRowConverter {
 
     private final SchemaDescriptor schemaDescriptor;
 
-    private final TableDescriptor desc;
+    private final int[] physicalIndexMap;
 
     /** Constructor. */
     public TableRowConverterImpl(SchemaRegistry schemaRegistry, SchemaDescriptor schemaDescriptor, TableDescriptor desc) {
         this.schemaRegistry = schemaRegistry;
         this.schemaDescriptor = schemaDescriptor;
-        this.desc = desc;
+
+        physicalIndexMap = new int[desc.columnsCount()];
+
+        for (int i = 0; i < desc.columnsCount(); i++) {
+            ColumnDescriptor col = desc.columnDescriptor(i);
+            Column column = schemaDescriptor.column(col.name());
+            physicalIndexMap[i] = column.schemaIndex();
+        }
     }
 
     /** {@inheritDoc} */
@@ -59,21 +67,17 @@ public class TableRowConverterImpl implements TableRowConverter {
 
         RowT res = factory.create();
 
-        assert handler.columnCount(res) == (requiredColumns == null ? desc.columnsCount() : requiredColumns.cardinality());
+        assert handler.columnCount(res) == (requiredColumns == null ? physicalIndexMap.length : requiredColumns.cardinality());
 
         Row row = schemaRegistry.resolve(binaryRow, schemaDescriptor);
 
         if (requiredColumns == null) {
-            for (int i = 0; i < desc.columnsCount(); i++) {
-                ColumnDescriptor colDesc = desc.columnDescriptor(i);
-
-                handler.set(i, res, TypeUtils.toInternal(row.value(colDesc.physicalIndex())));
+            for (int i = 0; i < physicalIndexMap.length; i++) {
+                handler.set(i, res, TypeUtils.toInternal(row.value(physicalIndexMap[i])));
             }
         } else {
             for (int i = 0, j = requiredColumns.nextSetBit(0); j != -1; j = requiredColumns.nextSetBit(j + 1), i++) {
-                ColumnDescriptor colDesc = desc.columnDescriptor(j);
-
-                handler.set(i, res, TypeUtils.toInternal(row.value(colDesc.physicalIndex())));
+                handler.set(i, res, TypeUtils.toInternal(row.value(physicalIndexMap[j])));
             }
         }
 
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/UpdatableTableImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/UpdatableTableImpl.java
index 97889cc187..1c3d8dcb9a 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/UpdatableTableImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/UpdatableTableImpl.java
@@ -114,7 +114,9 @@ public final class UpdatableTableImpl implements UpdatableTable {
         for (int i = 0; i < desc.columnsCount(); i++) {
             ColumnDescriptor columnDescriptor = desc.columnDescriptor(i);
 
-            tmp[columnDescriptor.physicalIndex()] = columnDescriptor;
+            int physIndex = schemaDescriptor.column(columnDescriptor.name()).schemaIndex();
+
+            tmp[physIndex] = columnDescriptor;
         }
 
         columnsOrderedByPhysSchema = tmp;
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/rel/IndexScanNode.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/rel/IndexScanNode.java
index 55ad834cdf..516f527786 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/rel/IndexScanNode.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/rel/IndexScanNode.java
@@ -25,12 +25,15 @@ import java.util.List;
 import java.util.concurrent.Flow.Publisher;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import org.apache.calcite.rel.RelFieldCollation;
 import org.apache.ignite.internal.sql.engine.exec.ExecutionContext;
 import org.apache.ignite.internal.sql.engine.exec.RowHandler;
 import org.apache.ignite.internal.sql.engine.exec.ScannableTable;
 import org.apache.ignite.internal.sql.engine.exec.exp.RangeCondition;
 import org.apache.ignite.internal.sql.engine.exec.exp.RangeIterable;
 import org.apache.ignite.internal.sql.engine.metadata.PartitionWithTerm;
+import org.apache.ignite.internal.sql.engine.schema.ColumnDescriptor;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
 import org.apache.ignite.internal.sql.engine.schema.TableDescriptor;
 import org.apache.ignite.internal.sql.engine.util.Commons;
@@ -59,6 +62,8 @@ public class IndexScanNode<RowT> extends StorageScanNode<RowT> {
 
     private final @Nullable Comparator<RowT> comp;
 
+    private final List<String> columns;
+
     /**
      * Constructor.
      *
@@ -96,6 +101,12 @@ public class IndexScanNode<RowT> extends StorageScanNode<RowT> {
         this.rangeConditions = rangeConditions;
         this.comp = comp;
         this.factory = rowFactory;
+
+        columns = schemaIndex.collation().getFieldCollations().stream()
+                .map(RelFieldCollation::getFieldIndex)
+                .map(tableDescriptor::columnDescriptor)
+                .map(ColumnDescriptor::name)
+                .collect(Collectors.toList());
     }
 
     /** {@inheritDoc} */
@@ -124,7 +135,6 @@ public class IndexScanNode<RowT> extends StorageScanNode<RowT> {
 
     private Publisher<RowT> partitionPublisher(PartitionWithTerm partWithTerm, @Nullable RangeCondition<RowT> cond) {
         int indexId = schemaIndex.id();
-        List<String> columns = schemaIndex.columns();
         ExecutionContext<RowT> ctx = context();
 
         switch (schemaIndex.type()) {
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 ae84daaf49..eb82b0d456 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
@@ -28,7 +28,7 @@ import java.util.Objects;
 public class CacheKey {
     static final Class<?>[] EMPTY_CLASS_ARRAY = {};
 
-    private final long catalogVersion;
+    private final int catalogVersion;
 
     private final String schemaName;
 
@@ -48,7 +48,7 @@ public class CacheKey {
      *                   LOCAL flag)
      * @param paramTypes Types of all dynamic parameters, no any type can be {@code null}.
      */
-    public CacheKey(long catalogVersion, String schemaName, String query, Object contextKey, Class<?>[] paramTypes) {
+    public CacheKey(int catalogVersion, String schemaName, String query, Object contextKey, Class<?>[] paramTypes) {
         this.catalogVersion = catalogVersion;
         this.schemaName = schemaName;
         this.query = query;
@@ -86,7 +86,7 @@ public class CacheKey {
 
     @Override
     public int hashCode() {
-        int result = Long.hashCode(catalogVersion);
+        int result = catalogVersion;
         result = 31 * result + schemaName.hashCode();
         result = 31 * result + query.hashCode();
         result = 31 * result + (contextKey != null ? contextKey.hashCode() : 0);
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 12ccee6fdd..84d56b8789 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
@@ -305,7 +305,7 @@ 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();
+        int catalogVersion = ctx.unwrap(BaseQueryContext.class).schemaVersion();
 
         Class[] paramTypes = ctx.parameters().length == 0
                 ? EMPTY_CLASS_ARRAY :
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalIndexScan.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalIndexScan.java
index d76a263c68..5b6efda630 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalIndexScan.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalIndexScan.java
@@ -30,7 +30,6 @@ import org.apache.ignite.internal.sql.engine.rel.AbstractIndexScan;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex.Type;
 import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
-import org.apache.ignite.internal.sql.engine.trait.TraitUtils;
 import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
 import org.apache.ignite.internal.sql.engine.util.Commons;
 import org.apache.ignite.internal.sql.engine.util.RexUtils;
@@ -53,8 +52,8 @@ public class IgniteLogicalIndexScan extends AbstractIndexScan {
     ) {
         IgniteTable tbl = table.unwrap(IgniteTable.class);
         IgniteTypeFactory typeFactory = Commons.typeFactory(cluster);
-        IgniteIndex index = tbl.getIndex(idxName);
-        RelCollation collation = TraitUtils.createCollation(index.columns(), index.collations(), tbl.descriptor());
+        IgniteIndex index = tbl.indexes().get(idxName);
+        RelCollation collation = index.collation();
 
         List<SearchBounds> searchBounds;
         if (index.type() == Type.HASH) {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/LogicalScanConverterRule.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/LogicalScanConverterRule.java
index 836cfe19de..e5bd22f03f 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/LogicalScanConverterRule.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/LogicalScanConverterRule.java
@@ -42,7 +42,6 @@ import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex.Type;
 import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
-import org.apache.ignite.internal.sql.engine.trait.TraitUtils;
 
 /**
  * LogicalScanConverterRule.
@@ -62,10 +61,10 @@ public abstract class LogicalScanConverterRule<T extends ProjectableFilterableTa
                 ) {
                     RelOptCluster cluster = rel.getCluster();
                     IgniteTable table = rel.getTable().unwrap(IgniteTable.class);
-                    IgniteIndex index = table.getIndex(rel.indexName());
+                    IgniteIndex index = table.indexes().get(rel.indexName());
 
                     RelDistribution distribution = table.distribution();
-                    RelCollation collation = TraitUtils.createCollation(index.columns(), index.collations(), table.descriptor());
+                    RelCollation collation = index.collation();
                     RelCollation outputCollation = index.type() == Type.HASH ? RelCollations.EMPTY : collation;
 
                     if (rel.projects() != null || rel.requiredColumns() != null) {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/ExposeIndexRule.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/ExposeIndexRule.java
index ffd52389dd..66f340726f 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/ExposeIndexRule.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/ExposeIndexRule.java
@@ -66,8 +66,8 @@ public class ExposeIndexRule extends RelRule<ExposeIndexRule.Config> {
         RexNode condition = scan.condition();
         ImmutableBitSet requiredCols = scan.requiredColumns();
 
-        List<IgniteLogicalIndexScan> indexes = igniteTable.indexes().keySet().stream()
-                .map(idxName -> igniteTable.toRel(cluster, optTable, idxName, proj, condition, requiredCols))
+        List<IgniteLogicalIndexScan> indexes = igniteTable.indexes().values().stream()
+                .map(idx -> idx.toRel(cluster, optTable, proj, condition, requiredCols))
                 .filter(idx -> filter(igniteTable, idx.indexName(), idx.searchBounds()))
                 .collect(Collectors.toList());
 
@@ -85,7 +85,7 @@ public class ExposeIndexRule extends RelRule<ExposeIndexRule.Config> {
 
     /** Filter pre known not applicable variants. Significant shrink search space in some cases. */
     private static boolean filter(IgniteTable table, String idxName, List<SearchBounds> searchBounds) {
-        IgniteIndex index = table.getIndex(idxName);
+        IgniteIndex index = table.indexes().get(idxName);
 
         return index.type() == Type.SORTED || (searchBounds != null
                 && searchBounds.stream().noneMatch(bound -> bound.type() == SearchBounds.Type.RANGE));
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/LogicalOrToUnionRule.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/LogicalOrToUnionRule.java
index 2c58e626fc..3676e75b0e 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/LogicalOrToUnionRule.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/LogicalOrToUnionRule.java
@@ -39,7 +39,6 @@ import org.apache.calcite.util.mapping.Mappings;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
 import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
-import org.apache.ignite.internal.sql.engine.trait.TraitUtils;
 import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
 import org.apache.ignite.internal.sql.engine.util.Commons;
 import org.apache.ignite.internal.util.CollectionUtils;
@@ -139,8 +138,7 @@ public class LogicalOrToUnionRule extends RelRule<LogicalOrToUnionRule.Config> {
         BitSet idxsFirstFields = new BitSet(fieldCnt);
 
         for (IgniteIndex idx : tbl.indexes().values()) {
-            List<RelFieldCollation> fieldCollations = TraitUtils.createCollation(idx.columns(), idx.collations(), tbl.descriptor())
-                    .getFieldCollations();
+            List<RelFieldCollation> fieldCollations = idx.collation().getFieldCollations();
 
             if (!CollectionUtils.nullOrEmpty(fieldCollations)) {
                 idxsFirstFields.set(fieldCollations.get(0).getFieldIndex());
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/CatalogColumnDescriptor.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/CatalogColumnDescriptor.java
index 3cc05cc624..4330d5b244 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/CatalogColumnDescriptor.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/CatalogColumnDescriptor.java
@@ -130,12 +130,6 @@ public final class CatalogColumnDescriptor implements ColumnDescriptor {
         return index;
     }
 
-    /** {@inheritDoc} */
-    @Override
-    public int physicalIndex() {
-        return index;
-    }
-
     /** {@inheritDoc} */
     @Override
     public NativeType physicalType() {
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 f8cd38e680..ecfac3cc45 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
@@ -24,7 +24,6 @@ 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;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
@@ -35,7 +34,6 @@ import java.util.concurrent.ConcurrentMap;
 import java.util.function.Supplier;
 import org.apache.calcite.rel.RelCollation;
 import org.apache.calcite.schema.SchemaPlus;
-import org.apache.calcite.schema.Table;
 import org.apache.calcite.tools.Frameworks;
 import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.catalog.CatalogService;
@@ -66,7 +64,11 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
     /** Constructor. */
     public CatalogSqlSchemaManager(CatalogManager catalogManager, int cacheSize) {
         this.catalogManager = catalogManager;
-        this.cache = Caffeine.newBuilder().maximumSize(cacheSize).<Map.Entry<String, Integer>, SchemaPlus>build().asMap();
+        this.cache = Caffeine.newBuilder()
+                .initialCapacity(cacheSize)
+                .maximumSize(cacheSize)
+                .<Map.Entry<String, Integer>, SchemaPlus>build()
+                .asMap();
     }
 
     /** {@inheritDoc} */
@@ -81,19 +83,9 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
     /** {@inheritDoc} */
     @Override
     public SchemaPlus schema(@Nullable String name, long timestamp) {
-        String schemaName = name == null ? DEFAULT_SCHEMA_NAME : name;
-
         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())));
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteTable tableById(int id) {
-        // Should be removed - this method is used to obtain native types from a table.
-        throw new UnsupportedOperationException();
+        return schema(name, schemaVersion);
     }
 
     /** {@inheritDoc} */
@@ -107,7 +99,7 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
         String schemaName = schemaDescriptor.name();
 
         int numTables = schemaDescriptor.tables().length;
-        Map<String, Table> schemaTables = new HashMap<>(numTables);
+        List<IgniteTable> schemaTables = new ArrayList<>(numTables);
         Int2ObjectMap<TableDescriptor> tableDescriptorMap = new Int2ObjectOpenHashMap<>(numTables);
 
         // Assemble sql-engine.TableDescriptors as they are required by indexes.
@@ -116,7 +108,7 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
             tableDescriptorMap.put(tableDescriptor.id(), descriptor);
         }
 
-        Int2ObjectMap<Map<String, IgniteSchemaIndex>> schemaTableIndexes = new Int2ObjectOpenHashMap<>(schemaDescriptor.indexes().length);
+        Int2ObjectMap<Map<String, IgniteIndex>> schemaTableIndexes = new Int2ObjectOpenHashMap<>(schemaDescriptor.indexes().length);
 
         // Assemble indexes as they are required by tables.
         for (CatalogIndexDescriptor indexDescriptor : schemaDescriptor.indexes()) {
@@ -125,9 +117,9 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
             assert tableDescriptor != null : "Table is not found in schema: " + tableId;
 
             String indexName = indexDescriptor.name();
-            Map<String, IgniteSchemaIndex> tableIndexes = schemaTableIndexes.computeIfAbsent(tableId, id -> new LinkedHashMap<>());
+            Map<String, IgniteIndex> tableIndexes = schemaTableIndexes.computeIfAbsent(tableId, id -> new LinkedHashMap<>());
 
-            IgniteSchemaIndex schemaIndex = createSchemaIndex(indexDescriptor, tableDescriptor);
+            IgniteIndex schemaIndex = createSchemaIndex(indexDescriptor, tableDescriptor);
             tableIndexes.put(indexName, schemaIndex);
 
             schemaTableIndexes.put(tableId, tableIndexes);
@@ -141,20 +133,20 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
             assert descriptor != null;
 
             IgniteStatistic statistic = new IgniteStatistic(() -> 0.0d, descriptor.distribution());
-            Map<String, IgniteSchemaIndex> tableIndexMap = schemaTableIndexes.getOrDefault(tableId, Collections.emptyMap());
+            Map<String, IgniteIndex> tableIndexMap = schemaTableIndexes.getOrDefault(tableId, Collections.emptyMap());
 
             IgniteSchemaTable schemaTable = new IgniteSchemaTable(tableName, tableId, version, descriptor, statistic, tableIndexMap);
 
-            schemaTables.put(tableName, schemaTable);
+            schemaTables.add(schemaTable);
         }
 
         // create root schema
         SchemaPlus rootSchema = Frameworks.createRootSchema(false);
-        IgniteCatalogSchema igniteSchema = new IgniteCatalogSchema(schemaName, version, schemaTables);
+        IgniteSchema igniteSchema = new IgniteSchema(schemaName, version, schemaTables);
         return rootSchema.add(schemaName, igniteSchema);
     }
 
-    private static IgniteSchemaIndex createSchemaIndex(CatalogIndexDescriptor indexDescriptor, TableDescriptor tableDescriptor) {
+    private static IgniteIndex createSchemaIndex(CatalogIndexDescriptor indexDescriptor, TableDescriptor tableDescriptor) {
         Type type;
         if (indexDescriptor instanceof CatalogSortedIndexDescriptor) {
             type = Type.SORTED;
@@ -164,8 +156,8 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
             throw new IllegalArgumentException("Unexpected index type: " + indexDescriptor);
         }
 
-        RelCollation indexCollation = IgniteSchemaIndex.createIndexCollation(indexDescriptor, tableDescriptor);
-        return new IgniteSchemaIndex(indexDescriptor.name(), type, tableDescriptor.distribution(), indexCollation);
+        RelCollation indexCollation = IgniteIndex.createIndexCollation(indexDescriptor, tableDescriptor);
+        return new IgniteIndex(indexDescriptor.id(), indexDescriptor.name(), type, tableDescriptor.distribution(), indexCollation);
     }
 
     private static TableDescriptor createTableDescriptor(CatalogTableDescriptor descriptor) {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/ColumnDescriptor.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/ColumnDescriptor.java
index 90a07956b4..49afb4fac2 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/ColumnDescriptor.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/ColumnDescriptor.java
@@ -39,9 +39,6 @@ public interface ColumnDescriptor {
     /** Returns 0-based index of the column according to a schema defined by a user. */
     int logicalIndex();
 
-    /** Returns 0-based index of the column according to an actual row layout defined by a storage. */
-    int physicalIndex();
-
     /** Returns the type of this column in a storage. */
     NativeType physicalType();
 
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/ColumnDescriptorImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/ColumnDescriptorImpl.java
index 2dcc455ecb..cecc2df445 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/ColumnDescriptorImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/ColumnDescriptorImpl.java
@@ -40,8 +40,6 @@ public class ColumnDescriptorImpl implements ColumnDescriptor {
 
     private final int logicalIndex;
 
-    private final int physicalIndex;
-
     private final NativeType storageType;
 
     /**
@@ -51,7 +49,6 @@ public class ColumnDescriptorImpl implements ColumnDescriptor {
      * @param key If {@code true}, this column will be considered as a part of PK.
      * @param nullable If {@code true}, this column will be considered as a nullable.
      * @param logicalIndex A 0-based index in a schema defined by a user.
-     * @param physicalIndex A 0-based index in a schema defined by a storage.
      * @param type Type of the value in the underlying storage.
      * @param defaultStrategy A strategy to follow when generating value for column not specified in the INSERT statement.
      * @param dfltVal A value generator to use when generating value for column not specified in the INSERT statement.
@@ -63,7 +60,6 @@ public class ColumnDescriptorImpl implements ColumnDescriptor {
             boolean key,
             boolean nullable,
             int logicalIndex,
-            int physicalIndex,
             NativeType type,
             DefaultValueStrategy defaultStrategy,
             @Nullable Supplier<Object> dfltVal
@@ -73,7 +69,6 @@ public class ColumnDescriptorImpl implements ColumnDescriptor {
         this.name = name;
         this.defaultStrategy = defaultStrategy;
         this.logicalIndex = logicalIndex;
-        this.physicalIndex = physicalIndex;
         this.storageType = type;
 
         this.dfltVal = defaultStrategy != DefaultValueStrategy.DEFAULT_NULL
@@ -117,12 +112,6 @@ public class ColumnDescriptorImpl implements ColumnDescriptor {
         return logicalIndex;
     }
 
-    /** {@inheritDoc} */
-    @Override
-    public int physicalIndex() {
-        return physicalIndex;
-    }
-
     /** {@inheritDoc} */
     @Override
     public NativeType physicalType() {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteCatalogSchema.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteCatalogSchema.java
deleted file mode 100644
index 6150cf7bbb..0000000000
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteCatalogSchema.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * 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.internal.sql.engine.schema;
-
-import java.util.Collections;
-import java.util.Map;
-import org.apache.calcite.schema.Table;
-import org.apache.calcite.schema.impl.AbstractSchema;
-
-/**
- * Schema adapter for apache calcite.
- */
-public class IgniteCatalogSchema extends AbstractSchema {
-
-    private final String name;
-
-    private final int version;
-
-    private final Map<String, Table> tableMap;
-
-    /** Constructor. */
-    public IgniteCatalogSchema(String name, int version, Map<String, Table> tableMap) {
-        this.name = name;
-        this.version = version;
-        this.tableMap = tableMap;
-    }
-
-    /** Schema name. */
-    public String getName() {
-        return name;
-    }
-
-    /** Schema version. */
-    public int version() {
-        return version;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    protected Map<String, Table> getTableMap() {
-        return Collections.unmodifiableMap(tableMap);
-    }
-}
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteIndex.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteIndex.java
index 244ccc3784..03a0b3a21b 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteIndex.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteIndex.java
@@ -21,16 +21,29 @@ import static org.apache.ignite.internal.sql.engine.util.TypeUtils.native2relati
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelCollations;
+import org.apache.calcite.rel.RelFieldCollation;
+import org.apache.calcite.rel.RelFieldCollation.Direction;
+import org.apache.calcite.rel.RelFieldCollation.NullDirection;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.ignite.internal.index.ColumnCollation;
-import org.apache.ignite.internal.index.Index;
-import org.apache.ignite.internal.index.SortedIndex;
-import org.apache.ignite.internal.index.SortedIndexDescriptor;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.util.ImmutableBitSet;
+import org.apache.calcite.util.mapping.Mapping;
+import org.apache.calcite.util.mapping.Mappings;
+import org.apache.ignite.internal.catalog.descriptors.CatalogHashIndexDescriptor;
+import org.apache.ignite.internal.catalog.descriptors.CatalogIndexColumnDescriptor;
+import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
+import org.apache.ignite.internal.catalog.descriptors.CatalogSortedIndexDescriptor;
+import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
+import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
 import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.TestOnly;
+import org.apache.ignite.internal.sql.engine.util.Commons;
 
 /**
  * Schema object representing an Index.
@@ -68,123 +81,156 @@ public class IgniteIndex {
         HASH, SORTED
     }
 
-    private final List<String> columns;
+    private final int id;
 
-    private final @Nullable List<Collation> collations;
+    private final String name;
 
-    private final Index<?> index;
+    private final IgniteDistribution tableDistribution;
+
+    private final RelCollation collation;
 
     private final Type type;
 
-    /**
-     * Constructs the Index object.
-     *
-     * @param index A data access object to wrap.
-     */
-    public IgniteIndex(Index<?> index) {
-        this.index = Objects.requireNonNull(index, "index");
+    private RelDataType rowType;
 
-        this.columns = index.descriptor().columns();
-        this.collations = deriveCollations(index);
-        this.type = index instanceof SortedIndex ? Type.SORTED : Type.HASH;
+    /** Constructor. */
+    public IgniteIndex(int id, String name, Type type, IgniteDistribution tableDistribution, RelCollation collation) {
+        this.id = id;
+        this.name = name;
+        this.type = type;
+        this.tableDistribution = tableDistribution;
+        this.collation = collation;
     }
 
-    /**
-     * Constructs the Index object.
-     */
-    @TestOnly
-    public IgniteIndex(Type type, List<String> columns, @Nullable List<Collation> collations) {
-        assert type == Type.SORTED ^ collations == null;
+    /** Returns an id of the index. */
+    public int id() {
+        return id;
+    }
 
-        this.columns = columns;
-        this.collations = collations;
-        this.type = type;
+    /** Returns the name of this index. */
+    public String name() {
+        return name;
+    }
 
-        index = null;
+    /** Returns the type of this index. */
+    public Type type() {
+        return type;
     }
 
-    /** Returns a list of names of indexed columns. */
-    public List<String> columns() {
-        return columns;
+    /** Returns the collation of this index. */
+    public RelCollation collation() {
+        return collation;
+    }
+
+    /** Returns index row type. */
+    public RelDataType rowType(IgniteTypeFactory factory, TableDescriptor tableDescriptor) {
+        if (rowType == null) {
+            rowType = createRowType(factory, tableDescriptor, collation);
+        }
+        return rowType;
     }
 
     /**
-     * Returns a list of collations.
-     *
-     * <p>The size of the collations list is guaranteed to match the size of indexed columns. The i-th
-     * collation is related to an i-th column.
-     *
-     * @return The list of collations or {@code null} if not applicable.
+     * Translates this index into relational operator.
      */
-    public @Nullable List<Collation> collations() {
-        return collations;
+    public IgniteLogicalIndexScan toRel(
+            RelOptCluster cluster,
+            RelOptTable relOptTable,
+            List<RexNode> proj,
+            RexNode condition,
+            ImmutableBitSet requiredCols
+    ) {
+        RelTraitSet traitSet = cluster.traitSetOf(Convention.Impl.NONE)
+                .replace(tableDistribution)
+                .replace(type() == Type.HASH ? RelCollations.EMPTY : collation);
+
+        return IgniteLogicalIndexScan.create(cluster, traitSet, relOptTable, name, proj, condition, requiredCols);
     }
 
-    /** Returns the name of a current index. */
-    public String name() {
-        return index.name();
-    }
+    static RelCollation createIndexCollation(CatalogIndexDescriptor descriptor, TableDescriptor tableDescriptor) {
+        if (descriptor instanceof CatalogSortedIndexDescriptor) {
+            CatalogSortedIndexDescriptor sortedIndexDescriptor = (CatalogSortedIndexDescriptor) descriptor;
+            List<CatalogIndexColumnDescriptor> columns = sortedIndexDescriptor.columns();
+            List<RelFieldCollation> fieldCollations = new ArrayList<>(columns.size());
+
+            for (int i = 0; i < columns.size(); i++) {
+                CatalogIndexColumnDescriptor column = columns.get(i);
+                ColumnDescriptor columnDesc = tableDescriptor.columnDescriptor(column.name());
+                int fieldIndex = columnDesc.logicalIndex();
+
+                RelFieldCollation fieldCollation;
+                switch (column.collation()) {
+                    case ASC_NULLS_FIRST:
+                        fieldCollation = new RelFieldCollation(fieldIndex, Direction.ASCENDING, NullDirection.FIRST);
+                        break;
+                    case ASC_NULLS_LAST:
+                        fieldCollation = new RelFieldCollation(fieldIndex, Direction.ASCENDING, NullDirection.LAST);
+                        break;
+                    case DESC_NULLS_FIRST:
+                        fieldCollation = new RelFieldCollation(fieldIndex, Direction.DESCENDING, NullDirection.FIRST);
+                        break;
+                    case DESC_NULLS_LAST:
+                        fieldCollation = new RelFieldCollation(fieldIndex, Direction.DESCENDING, NullDirection.LAST);
+                        break;
+                    default:
+                        throw new IllegalArgumentException("Unexpected collation: " + column.collation());
+                }
+
+                fieldCollations.add(fieldCollation);
+            }
 
-    /** Returns an object providing access to a data. */
-    public Index<?> index() {
-        return index;
-    }
+            return RelCollations.of(fieldCollations);
+        } else if (descriptor instanceof CatalogHashIndexDescriptor) {
+            CatalogHashIndexDescriptor hashIndexDescriptor = (CatalogHashIndexDescriptor) descriptor;
+            List<String> columns = hashIndexDescriptor.columns();
+            List<RelFieldCollation> fieldCollations = new ArrayList<>(columns.size());
 
-    /** Returns id of this index. */
-    public int id() {
-        return index.id();
-    }
+            for (String columnName : columns) {
+                ColumnDescriptor columnDesc = tableDescriptor.columnDescriptor(columnName);
 
-    public int tableId() {
-        return index.tableId();
-    }
+                fieldCollations.add(new RelFieldCollation(columnDesc.logicalIndex(), Direction.CLUSTERED, NullDirection.UNSPECIFIED));
+            }
 
-    public Type type() {
-        return type;
+            return RelCollations.of(fieldCollations);
+        } else {
+            throw new IllegalArgumentException("Unexpected index type: " + descriptor);
+        }
     }
 
     //TODO: cache rowType as it can't be changed.
 
-    /** Returns index row type.
+    /**
+     * Returns index row type.
      *
      * <p>This is a struct type whose fields describe the names and types of indexed columns.</p>
      *
      * <p>The implementer must use the type factory provided. This ensures that
-     * the type is converted into a canonical form; other equal types in the same
-     * query will use the same object.</p>
+     * the type is converted into a canonical form; other equal types in the same query will use the same object.</p>
      *
      * @param typeFactory Type factory with which to create the type
      * @param tableDescriptor Table descriptor.
+     * @param collation Index collation.
      * @return Row type.
      */
-    public RelDataType getRowType(IgniteTypeFactory typeFactory, TableDescriptor tableDescriptor) {
+    public static RelDataType createRowType(IgniteTypeFactory typeFactory, TableDescriptor tableDescriptor, RelCollation collation) {
         RelDataTypeFactory.Builder b = new RelDataTypeFactory.Builder(typeFactory);
 
-        for (String colName : columns) {
-            ColumnDescriptor colDesc = tableDescriptor.columnDescriptor(colName);
-            b.add(colName, native2relationalType(typeFactory, colDesc.physicalType(), colDesc.nullable()));
+        for (RelFieldCollation field : collation.getFieldCollations()) {
+            ColumnDescriptor colDesc = tableDescriptor.columnDescriptor(field.getFieldIndex());
+            b.add(colDesc.name(), native2relationalType(typeFactory, colDesc.physicalType(), colDesc.nullable()));
         }
 
         return b.build();
     }
 
-    private static @Nullable List<Collation> deriveCollations(Index<?> index) {
-        if (index.descriptor() instanceof SortedIndexDescriptor) {
-            SortedIndexDescriptor descriptor = (SortedIndexDescriptor) index.descriptor();
-
-            List<Collation> orders = new ArrayList<>(descriptor.columns().size());
+    /** Index row collation. */
+    public static RelCollation deriveCollations(IgniteIndex index, int targetSize) {
+        assert index.type == Type.SORTED;
 
-            for (var column : descriptor.columns()) {
-                ColumnCollation collation = descriptor.collation(column);
+        List<RelFieldCollation> fieldCollations = index.collation().getFieldCollations();
 
-                assert collation != null;
-
-                orders.add(Collation.of(collation.asc(), collation.nullsFirst()));
-            }
-
-            return List.copyOf(orders);
-        }
+        Mapping mapping = Mappings.target(RelCollations.ordinals(fieldCollations), targetSize);
 
-        return null;
+        return RelCollations.permute(index.collation(), mapping);
     }
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchema.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchema.java
index 8163917c19..5aa9dd27a1 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchema.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchema.java
@@ -17,135 +17,63 @@
 
 package org.apache.ignite.internal.sql.engine.schema;
 
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 import org.apache.calcite.schema.Table;
 import org.apache.calcite.schema.impl.AbstractSchema;
-import org.jetbrains.annotations.Nullable;
+import org.apache.ignite.internal.util.CollectionUtils;
+import org.jetbrains.annotations.TestOnly;
 
 /**
- * Ignite schema.
+ * Schema adapter for apache calcite.
  */
 public class IgniteSchema extends AbstractSchema {
-    static final int INITIAL_VERSION = -1;
 
-    private final String schemaName;
+    private final String name;
 
-    private final Map<String, Table> tblMap;
+    private final int version;
 
-    private final Map<Integer, IgniteIndex> idxMap;
+    private final Map<String, IgniteTable> tableMapByName;
+    private final Int2ObjectMap<IgniteTable> tableMapById;
 
-    private final int schemaVersion;
-
-    /**
-     * Creates a Schema with given tables and indexes.
-     *
-     * @param schemaName A name of the schema to create.
-     * @param tableMap A collection of a tables belonging to the schema.
-     * @param indexMap A collection of an indexes belonging to the schema.
-     */
-    public IgniteSchema(
-            String schemaName,
-            @Nullable Map<String, Table> tableMap,
-            @Nullable Map<Integer, IgniteIndex> indexMap,
-            int schemaVersion
-    ) {
-        this.schemaName = schemaName;
-        this.tblMap = tableMap == null ? new ConcurrentHashMap<>() : new ConcurrentHashMap<>(tableMap);
-        this.idxMap = indexMap == null ? new ConcurrentHashMap<>() : new ConcurrentHashMap<>(indexMap);
-        this.schemaVersion = schemaVersion;
+    /** Constructor. */
+    public IgniteSchema(String name, int version, Collection<IgniteTable> tables) {
+        this.name = name;
+        this.version = version;
+        this.tableMapByName = tables.stream().collect(Collectors.toMap(t -> t.name().toUpperCase(), Function.identity()));
+        this.tableMapById = tables.stream().collect(CollectionUtils.toIntMapCollector(IgniteTable::id, Function.identity()));
     }
 
-    /**
-     * Creates an empty Schema.
-     *
-     * @param schemaName A name of the schema to create.
-     */
-    public IgniteSchema(String schemaName) {
-        this(schemaName, null, null, INITIAL_VERSION);
+    /** Constructor. */
+    @TestOnly
+    public IgniteSchema(String name) {
+        this(name, 0, List.of());
     }
 
-    /**
-     * Creates an empty Schema.
-     *
-     * @param schemaName A name of the schema to create.
-     */
-    public IgniteSchema(String schemaName, int schemaVersion) {
-        this(schemaName, null, null, schemaVersion);
-    }
 
-    public static IgniteSchema copy(IgniteSchema old, int schemaVersion) {
-        return new IgniteSchema(old.schemaName, old.tblMap, old.idxMap, schemaVersion);
+    /** Schema name. */
+    public String getName() {
+        return name;
     }
 
-    /**
-     * Get schema name.
-     *
-     * @return Schema name.
-     */
-    public String getName() {
-        return schemaName;
+    /** Schema version. */
+    public int version() {
+        return version;
     }
 
     /** {@inheritDoc} */
     @Override
     protected Map<String, Table> getTableMap() {
-        return Collections.unmodifiableMap(tblMap);
-    }
-
-    /**
-     * Add table.
-     *
-     * @param tbl Table.
-     */
-    public void addTable(IgniteTable tbl) {
-        tblMap.put(tbl.name(), tbl);
-    }
-
-    /**
-     * Remove table.
-     *
-     * @param tblName Table name.
-     */
-    public void removeTable(String tblName) {
-        tblMap.remove(tblName);
-    }
-
-    /**
-     * Add index.
-     *
-     * @param indexId Index id.
-     * @param index Index.
-     */
-    public void addIndex(int indexId, IgniteIndex index) {
-        idxMap.put(indexId, index);
-    }
-
-    /**
-     * Remove index.
-     *
-     * @param indexId Index id.
-     * @return Removed index.
-     */
-    public IgniteIndex removeIndex(int indexId) {
-        return idxMap.remove(indexId);
-    }
-
-    /**
-     * Gets index by id.
-     *
-     * @param indexId Index id.
-     * @return Index.
-     */
-    public IgniteIndex index(int indexId) {
-        return idxMap.get(indexId);
+        return Collections.unmodifiableMap(tableMapByName);
     }
 
-    /**
-     * Return actual schema version.
-     */
-    public int schemaVersion() {
-        return schemaVersion;
+    /** Returns table by given id. */
+    public IgniteTable getTable(int tableId) {
+        return tableMapById.get(tableId);
     }
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchemaIndex.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchemaIndex.java
deleted file mode 100644
index 5a5171bca4..0000000000
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSchemaIndex.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * 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.internal.sql.engine.schema;
-
-import java.util.ArrayList;
-import java.util.List;
-import org.apache.calcite.plan.Convention;
-import org.apache.calcite.plan.RelOptCluster;
-import org.apache.calcite.plan.RelOptTable;
-import org.apache.calcite.plan.RelTraitSet;
-import org.apache.calcite.rel.RelCollation;
-import org.apache.calcite.rel.RelCollations;
-import org.apache.calcite.rel.RelFieldCollation;
-import org.apache.calcite.rel.RelFieldCollation.Direction;
-import org.apache.calcite.rel.RelFieldCollation.NullDirection;
-import org.apache.calcite.rex.RexNode;
-import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.ignite.internal.catalog.descriptors.CatalogHashIndexDescriptor;
-import org.apache.ignite.internal.catalog.descriptors.CatalogIndexColumnDescriptor;
-import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
-import org.apache.ignite.internal.catalog.descriptors.CatalogSortedIndexDescriptor;
-import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
-import org.apache.ignite.internal.sql.engine.schema.IgniteIndex.Type;
-import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
-
-/**
- * Auxiliary data structure to represent a table index.
- */
-public class IgniteSchemaIndex {
-
-    private final String name;
-
-    private final IgniteDistribution tableDistribution;
-
-    private final RelCollation collation;
-
-    private final Type type;
-
-    /** Constructor. */
-    public IgniteSchemaIndex(String name, Type type, IgniteDistribution tableDistribution, RelCollation collation) {
-        this.name = name;
-        this.type = type;
-        this.tableDistribution = tableDistribution;
-        this.collation = collation;
-    }
-
-    /** Returns the name of this index. */
-    public String name() {
-        return name;
-    }
-
-    /** Returns the type of this index. */
-    public Type type() {
-        return type;
-    }
-
-    /** Returns the collation of this index. */
-    public RelCollation collation() {
-        return collation;
-    }
-
-    /**
-     * Translates this index into relational operator.
-     */
-    public IgniteLogicalIndexScan toRel(
-            RelOptCluster cluster,
-            RelOptTable relOptTable,
-            List<RexNode> proj,
-            RexNode condition,
-            ImmutableBitSet requiredCols
-    ) {
-        RelTraitSet traitSet = cluster.traitSetOf(Convention.Impl.NONE)
-                .replace(tableDistribution)
-                .replace(type() == Type.HASH ? RelCollations.EMPTY : collation);
-
-        return IgniteLogicalIndexScan.create(cluster, traitSet, relOptTable, name, proj, condition, requiredCols);
-    }
-
-    static RelCollation createIndexCollation(CatalogIndexDescriptor descriptor, TableDescriptor tableDescriptor) {
-        if (descriptor instanceof CatalogSortedIndexDescriptor) {
-            CatalogSortedIndexDescriptor sortedIndexDescriptor = (CatalogSortedIndexDescriptor) descriptor;
-            List<CatalogIndexColumnDescriptor> columns = sortedIndexDescriptor.columns();
-            List<RelFieldCollation> fieldCollations = new ArrayList<>(columns.size());
-
-            for (int i = 0; i < columns.size(); i++) {
-                CatalogIndexColumnDescriptor column = columns.get(i);
-                ColumnDescriptor columnDesc = tableDescriptor.columnDescriptor(column.name());
-                int fieldIndex = columnDesc.logicalIndex();
-
-                RelFieldCollation fieldCollation;
-                switch (column.collation()) {
-                    case ASC_NULLS_FIRST:
-                        fieldCollation = new RelFieldCollation(fieldIndex, Direction.ASCENDING, NullDirection.FIRST);
-                        break;
-                    case ASC_NULLS_LAST:
-                        fieldCollation = new RelFieldCollation(fieldIndex, Direction.ASCENDING, NullDirection.LAST);
-                        break;
-                    case DESC_NULLS_FIRST:
-                        fieldCollation = new RelFieldCollation(fieldIndex, Direction.DESCENDING, NullDirection.FIRST);
-                        break;
-                    case DESC_NULLS_LAST:
-                        fieldCollation = new RelFieldCollation(fieldIndex, Direction.DESCENDING, NullDirection.LAST);
-                        break;
-                    default:
-                        throw new IllegalArgumentException("Unexpected collation: " + column.collation());
-                }
-
-                fieldCollations.add(fieldCollation);
-            }
-
-            return RelCollations.of(fieldCollations);
-        } else if (descriptor instanceof CatalogHashIndexDescriptor) {
-            CatalogHashIndexDescriptor hashIndexDescriptor = (CatalogHashIndexDescriptor) descriptor;
-            List<String> columns = hashIndexDescriptor.columns();
-            List<RelFieldCollation> fieldCollations = new ArrayList<>(columns.size());
-
-            for (String columnName : columns) {
-                ColumnDescriptor columnDesc = tableDescriptor.columnDescriptor(columnName);
-
-                fieldCollations.add(new RelFieldCollation(columnDesc.logicalIndex(), Direction.CLUSTERED, NullDirection.UNSPECIFIED));
-            }
-
-            return RelCollations.of(fieldCollations);
-        } else {
-            throw new IllegalArgumentException("Unexpected index type: " + descriptor);
-        }
-    }
-}
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 74cee2f891..74337c53c2 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
@@ -34,7 +34,6 @@ import org.apache.calcite.schema.impl.AbstractTable;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan;
 import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
 import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
@@ -55,11 +54,11 @@ public final class IgniteSchemaTable extends AbstractTable implements IgniteTabl
 
     private final IgniteStatistic statistic;
 
-    private final Map<String, IgniteSchemaIndex> indexMap;
+    private final Map<String, IgniteIndex> indexMap;
 
     /** Constructor. */
     public IgniteSchemaTable(String name, int tableId,  int version, TableDescriptor desc,
-            IgniteStatistic statistic, Map<String, IgniteSchemaIndex> indexMap) {
+            IgniteStatistic statistic, Map<String, IgniteIndex> indexMap) {
 
         this.id = tableId;
         this.name = name;
@@ -117,12 +116,6 @@ public final class IgniteSchemaTable extends AbstractTable implements IgniteTabl
         return toRel(cluster, relOptTbl, hints, null, null, null);
     }
 
-    /** {@inheritDoc} */
-    @Override
-    public IgniteLogicalIndexScan toRel(RelOptCluster cluster, RelOptTable relOptTbl, String idxName) {
-        return toRel(cluster, relOptTbl, idxName, null, null, null);
-    }
-
     /** {@inheritDoc} */
     @Override
     public IgniteLogicalTableScan toRel(
@@ -138,20 +131,6 @@ public final class IgniteSchemaTable extends AbstractTable implements IgniteTabl
         return IgniteLogicalTableScan.create(cluster, traitSet, hints, relOptTbl, proj, cond, requiredColumns);
     }
 
-    /** {@inheritDoc} */
-    @Override
-    public IgniteLogicalIndexScan toRel(
-            RelOptCluster cluster,
-            RelOptTable relOptTable,
-            String idxName,
-            List<RexNode> proj,
-            RexNode condition,
-            ImmutableBitSet requiredCols
-    ) {
-        // index related methods should only be present on index object.
-        throw new UnsupportedOperationException();
-    }
-
     /** {@inheritDoc} */
     @Override
     public IgniteDistribution distribution() {
@@ -186,7 +165,7 @@ public final class IgniteSchemaTable extends AbstractTable implements IgniteTabl
 
     /** {@inheritDoc} */
     @Override
-    public  <C> @Nullable C unwrap(Class<C> cls) {
+    public <C> @Nullable C unwrap(Class<C> cls) {
         if (cls.isInstance(desc)) {
             return cls.cast(desc);
         }
@@ -197,29 +176,6 @@ public final class IgniteSchemaTable extends AbstractTable implements IgniteTabl
     /** {@inheritDoc} */
     @Override
     public Map<String, IgniteIndex> indexes() {
-        throw new UnsupportedOperationException("getIndexes() should be used instead");
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public void addIndex(IgniteIndex idxTbl) {
-        throw new UnsupportedOperationException("IndexMap is not modifiable");
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteIndex getIndex(String idxName) {
-        throw new UnsupportedOperationException("getIndexes(name) should be used instead");
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public void removeIndex(String idxName) {
-        throw new UnsupportedOperationException("IndexMap is not modifiable");
-    }
-
-    /** Returns a map of indexes defined for this table. */
-    public Map<String, IgniteSchemaIndex> getIndexes() {
         return indexMap;
     }
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteTable.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteTable.java
index 1faaed98af..2df9980786 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteTable.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteTable.java
@@ -35,7 +35,6 @@ import org.apache.calcite.schema.Wrapper;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan;
 import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
 import org.jetbrains.annotations.Nullable;
@@ -104,18 +103,6 @@ public interface IgniteTable extends TranslatableTable, Wrapper {
         return toRel(cluster, relOptTbl, hints, null, null, null);
     }
 
-    /**
-     * Converts table into relational expression.
-     *
-     * @param cluster   Custer.
-     * @param relOptTbl Table.
-     * @param idxName   Index name.
-     * @return Table relational expression.
-     */
-    default IgniteLogicalIndexScan toRel(RelOptCluster cluster, RelOptTable relOptTbl, String idxName) {
-        return toRel(cluster, relOptTbl, idxName, null, null, null);
-    }
-
     /**
      * Converts table into table scan relational expression.
      */
@@ -128,18 +115,6 @@ public interface IgniteTable extends TranslatableTable, Wrapper {
             @Nullable ImmutableBitSet requiredColumns
     );
 
-    /**
-     * Converts table into index scan relational expression.
-     */
-    IgniteLogicalIndexScan toRel(
-            RelOptCluster cluster,
-            RelOptTable relOptTbl,
-            String idxName,
-            List<RexNode> proj,
-            RexNode condition,
-            ImmutableBitSet requiredCols
-    );
-
     /**
      * Returns table distribution.
      *
@@ -193,26 +168,4 @@ public interface IgniteTable extends TranslatableTable, Wrapper {
      * @return Indexes for the current table.
      */
     Map<String, IgniteIndex> indexes();
-
-    /**
-     * Adds index to table.
-     *
-     * @param idxTbl Index table.
-     */
-    void addIndex(IgniteIndex idxTbl);
-
-    /**
-     * Returns index by its name.
-     *
-     * @param idxName Index name.
-     * @return Index.
-     */
-    IgniteIndex getIndex(String idxName);
-
-    /**
-     * Returns index name.
-     *
-     * @param idxName Index name.
-     */
-    void removeIndex(String idxName);
 }
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 d07454e2a7..50849c5265 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
@@ -35,14 +35,6 @@ public interface SqlSchemaManager {
      */
     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);
-
     /**
      * Returns a future to wait for given SQL schema version readiness.
      *
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/TableDescriptorImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/TableDescriptorImpl.java
index af2bc9b78b..9a58fe2b8f 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/TableDescriptorImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/TableDescriptorImpl.java
@@ -106,7 +106,6 @@ public class TableDescriptorImpl extends NullInitializerExpressionFactory implem
                 desc.key(),
                 desc.nullable(),
                 desc.logicalIndex(),
-                desc.physicalIndex(),
                 desc.physicalType(),
                 DefaultValueStrategy.DEFAULT_COMPUTED,
                 () -> {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/trait/TraitUtils.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/trait/TraitUtils.java
index 858a6380b5..a1731075ea 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/trait/TraitUtils.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/trait/TraitUtils.java
@@ -58,7 +58,6 @@ import org.apache.calcite.rex.RexSlot;
 import org.apache.calcite.util.ControlFlowException;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.mapping.Mappings;
-import org.apache.ignite.internal.index.ColumnCollation;
 import org.apache.ignite.internal.sql.engine.rel.IgniteConvention;
 import org.apache.ignite.internal.sql.engine.rel.IgniteExchange;
 import org.apache.ignite.internal.sql.engine.rel.IgniteRel;
@@ -470,21 +469,6 @@ public class TraitUtils {
         return new RelFieldCollation(fieldIdx, Direction.ASCENDING, NullDirection.LAST);
     }
 
-    /**
-     * Creates field collation.
-     */
-    public static RelFieldCollation createFieldCollation(int fieldIdx, ColumnCollation collation) {
-        RelFieldCollation.Direction direction = collation.asc()
-                ? RelFieldCollation.Direction.ASCENDING
-                : RelFieldCollation.Direction.DESCENDING;
-
-        RelFieldCollation.NullDirection nullDirection = collation.nullsFirst()
-                ? RelFieldCollation.NullDirection.FIRST
-                : RelFieldCollation.NullDirection.LAST;
-
-        return new RelFieldCollation(fieldIdx, direction, nullDirection);
-    }
-
     /** Creates field collation. */
     public static RelFieldCollation createFieldCollation(int fieldIdx, IgniteIndex.Collation collation) {
         switch (collation) {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/BaseQueryContext.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/BaseQueryContext.java
index 2c5d48ce64..b6f46a7e3b 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/BaseQueryContext.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/BaseQueryContext.java
@@ -222,7 +222,7 @@ public final class BaseQueryContext extends AbstractQueryContext {
     }
 
     public int schemaVersion() {
-        return Objects.requireNonNull(schema().unwrap(IgniteSchema.class)).schemaVersion();
+        return Objects.requireNonNull(schema().unwrap(IgniteSchema.class)).version();
     }
 
     /**
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/HashFunctionFactoryImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/HashFunctionFactoryImpl.java
index 4ad5484257..8e67ec178e 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/HashFunctionFactoryImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/HashFunctionFactoryImpl.java
@@ -26,7 +26,7 @@ import org.apache.ignite.internal.schema.NativeType;
 import org.apache.ignite.internal.schema.NativeTypeSpec;
 import org.apache.ignite.internal.sql.engine.exec.RowHandler;
 import org.apache.ignite.internal.sql.engine.schema.ColumnDescriptor;
-import org.apache.ignite.internal.sql.engine.schema.SqlSchemaManager;
+import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
 import org.apache.ignite.internal.sql.engine.schema.TableDescriptor;
 import org.apache.ignite.internal.util.ColocationUtils;
 import org.apache.ignite.internal.util.HashCalculator;
@@ -35,11 +35,11 @@ import org.apache.ignite.internal.util.HashCalculator;
  * Factory for creating a function to calculate the hash of the specified fields of a row.
  */
 public class HashFunctionFactoryImpl<T> implements HashFunctionFactory<T> {
-    private final SqlSchemaManager sqlSchemaManager;
     private final RowHandler<T> rowHandler;
+    private final IgniteSchema schema;
 
-    public HashFunctionFactoryImpl(SqlSchemaManager sqlSchemaManager, RowHandler<T> rowHandler) {
-        this.sqlSchemaManager = sqlSchemaManager;
+    public HashFunctionFactoryImpl(IgniteSchema schema, RowHandler<T> rowHandler) {
+        this.schema = schema;
         this.rowHandler = rowHandler;
     }
 
@@ -48,7 +48,9 @@ public class HashFunctionFactoryImpl<T> implements HashFunctionFactory<T> {
     public RowHashFunction<T> create(int[] fields, int tableId) {
         int fieldCnt = fields.length;
         NativeType[] fieldTypes = new NativeType[fieldCnt];
-        TableDescriptor tblDesc = sqlSchemaManager.tableById(tableId).descriptor();
+
+        TableDescriptor tblDesc = schema.getTable(tableId).descriptor();
+
         ImmutableIntList colocationColumns = tblDesc.distribution().getKeys();
 
         assert colocationColumns.size() == fieldCnt : "fieldsCount=" + fieldCnt + ", colocationColumns=" + colocationColumns;
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistrySelfTest.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistrySelfTest.java
index c98ee0c454..740a1cba71 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistrySelfTest.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistrySelfTest.java
@@ -150,7 +150,7 @@ public class ExecutableTableRegistrySelfTest {
             when(schemaManager.schemaRegistry(tableId)).thenReturn(schemaRegistry);
             when(schemaRegistry.schema()).thenReturn(schemaDescriptor);
 
-            return registry.getTable(tableId, descriptor);
+            return registry.getTable(schemaVersion, tableId, descriptor);
         }
     }
 }
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverSelfTest.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverSelfTest.java
index 372cf5c93b..cc5a2e4d7a 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverSelfTest.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverSelfTest.java
@@ -22,6 +22,7 @@ import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.times;
@@ -102,8 +103,8 @@ public class ExecutionDependencyResolverSelfTest extends AbstractPlannerTest {
         tester.checkDependencies(deps, t1Id);
         tester.checkDependencies(deps, t2Id);
 
-        verify(registry, times(1)).getTable(eq(t1Id), same(td1));
-        verify(registry, times(1)).getTable(eq(t2Id), same(td2));
+        verify(registry, times(1)).getTable(anyInt(), eq(t1Id), anyString(), same(td1));
+        verify(registry, times(1)).getTable(anyInt(), eq(t2Id), anyString(), same(td2));
     }
 
     /**
@@ -122,7 +123,7 @@ public class ExecutionDependencyResolverSelfTest extends AbstractPlannerTest {
         CompletableFuture<ResolvedDependencies> f = tester.resolveDependencies("SELECT * FROM test1 WHERE id=1");
         tester.checkDependencies(f.join(), t1Id);
 
-        verify(registry, times(1)).getTable(eq(t1Id), same(td1));
+        verify(registry, times(1)).getTable(anyInt(), eq(t1Id), anyString(), same(td1));
     }
 
     /**
@@ -150,8 +151,8 @@ public class ExecutionDependencyResolverSelfTest extends AbstractPlannerTest {
         tester.checkDependencies(deps, t1Id);
         tester.checkDependencies(deps, t2Id);
 
-        verify(registry, times(1)).getTable(eq(t1Id), same(td1));
-        verify(registry, times(1)).getTable(eq(t2Id), same(td2));
+        verify(registry, times(1)).getTable(anyInt(), eq(t1Id), anyString(), same(td1));
+        verify(registry, times(1)).getTable(anyInt(), eq(t2Id), anyString(), same(td2));
     }
 
     /**
@@ -172,7 +173,7 @@ public class ExecutionDependencyResolverSelfTest extends AbstractPlannerTest {
         ResolvedDependencies deps = f.join();
         tester.checkDependencies(deps, t1Id);
 
-        verify(registry, times(1)).getTable(anyInt(), any(TableDescriptor.class));
+        verify(registry, times(1)).getTable(anyInt(), anyInt(), anyString(), any(TableDescriptor.class));
     }
 
     /**
@@ -260,14 +261,14 @@ public class ExecutionDependencyResolverSelfTest extends AbstractPlannerTest {
 
             CompletableFuture<ExecutableTable> f = CompletableFuture.completedFuture(executableTable);
 
-            when(registry.getTable(eq(tableId), any(TableDescriptor.class))).thenReturn(f);
+            when(registry.getTable(anyInt(), eq(tableId), anyString(), any(TableDescriptor.class))).thenReturn(f);
         }
 
         void setError(int tableId, Throwable err) {
             CompletableFuture<ExecutableTable> f = new CompletableFuture<>();
             f.completeExceptionally(err);
 
-            when(registry.getTable(eq(tableId), any(TableDescriptor.class))).thenReturn(f);
+            when(registry.getTable(anyInt(), eq(tableId), anyString(), any(TableDescriptor.class))).thenReturn(f);
         }
 
         void setColocationGroup(int tableId, CompletableFuture<ColocationGroup> group) {
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 1f9236fa41..974eb4f459 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
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.sql.engine.exec;
 
+import static org.apache.ignite.internal.catalog.CatalogService.DEFAULT_SCHEMA_NAME;
 import static org.apache.ignite.internal.sql.engine.util.Commons.FRAMEWORK_CONFIG;
 import static org.apache.ignite.internal.testframework.IgniteTestUtils.await;
 import static org.apache.ignite.internal.testframework.IgniteTestUtils.waitForCondition;
@@ -142,7 +143,7 @@ public class ExecutionServiceImplTest {
     private final TestTable table = createTable("TEST_TBL", 1_000_000, IgniteDistributions.random(),
             "ID", NativeTypes.INT32, "VAL", NativeTypes.INT32);
 
-    private final IgniteSchema schema = new IgniteSchema("PUBLIC", Map.of(table.name(), table), null, SCHEMA_VERSION);
+    private final IgniteSchema schema = new IgniteSchema(DEFAULT_SCHEMA_NAME, SCHEMA_VERSION, List.of(table));
 
     private final List<CapturingMailboxRegistry> mailboxes = new ArrayList<>();
 
@@ -592,8 +593,6 @@ public class ExecutionServiceImplTest {
 
         when(topologyService.localMember()).thenReturn(clusterNode);
 
-        when(schemaManagerMock.tableById(anyInt())).thenReturn(table);
-
         when(schemaManagerMock.schemaReadyFuture(isA(int.class))).thenReturn(CompletableFuture.completedFuture(null));
 
         TestExecutableTableRegistry executableTableRegistry = new TestExecutableTableRegistry();
@@ -787,7 +786,9 @@ public class ExecutionServiceImplTest {
                     MailboxRegistry mailboxRegistry,
                     ExchangeService exchangeService,
                     ResolvedDependencies deps) {
-                HashFunctionFactory<Object[]> funcFactory = new HashFunctionFactoryImpl<>(mock(SqlSchemaManager.class), ctx.rowHandler());
+                IgniteSchema schema = ctx.getRootSchema().unwrap(IgniteSchema.class);
+
+                HashFunctionFactory<Object[]> funcFactory = new HashFunctionFactoryImpl<>(schema, ctx.rowHandler());
 
                 return new LogicalRelImplementor<>(ctx, funcFactory, mailboxRegistry, exchangeService, deps) {
                     @Override
@@ -861,8 +862,7 @@ public class ExecutionServiceImplTest {
      *               String.class)}.
      * @return Instance of the {@link TestTable}.
      */
-    // TODO: copy-pasted from AbstractPlannerTest. Should be derived to an independent class.
-    protected TestTable createTable(String name, int size, IgniteDistribution distr, Object... fields) {
+    private static TestTable createTable(String name, int size, IgniteDistribution distr, Object... fields) {
         if (ArrayUtils.nullOrEmpty(fields) || fields.length % 2 != 0) {
             throw new IllegalArgumentException("'fields' should be non-null array with even number of elements");
         }
@@ -872,7 +872,7 @@ public class ExecutionServiceImplTest {
         for (int i = 0; i < fields.length; i += 2) {
             columns.add(
                     new ColumnDescriptorImpl(
-                            (String) fields[i], false, true, i, i,
+                            (String) fields[i], false, true, i,
                             (NativeType) fields[i + 1], DefaultValueStrategy.DEFAULT_NULL, null
                     )
             );
@@ -881,10 +881,9 @@ public class ExecutionServiceImplTest {
         return new TestTable(
                 new TableDescriptorImpl(columns, distr),
                 name,
-                size
-        ) {
-
-        };
+                size,
+                List.of()
+        );
     }
 
     private static class CapturingMailboxRegistry implements MailboxRegistry {
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/TestExecutableTableRegistry.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/TestExecutableTableRegistry.java
index 1dee68eaea..d9731c9d50 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/TestExecutableTableRegistry.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/TestExecutableTableRegistry.java
@@ -40,10 +40,15 @@ public final class TestExecutableTableRegistry implements ExecutableTableRegistr
 
     /** {@inheritDoc} */
     @Override
-    public CompletableFuture<ExecutableTable> getTable(int tableId, TableDescriptor tableDescriptor) {
+    public CompletableFuture<ExecutableTable> getTable(int schemaVersion, int tableId, TableDescriptor tableDescriptor) {
         return CompletableFuture.completedFuture(new TestExecutableTable(tableId, colocationGroupProvider));
     }
 
+    @Override
+    public CompletableFuture<ExecutableTable> getTable(int schemaVersion, int tableId, String tableName, TableDescriptor tableDescriptor) {
+        return this.getTable(schemaVersion, tableId, tableDescriptor);
+    }
+
     private static final class TestExecutableTable implements ExecutableTable {
 
         private final int tableId;
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/rel/IndexScanNodeExecutionTest.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/rel/IndexScanNodeExecutionTest.java
index b6463a543b..61879c1c12 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/rel/IndexScanNodeExecutionTest.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/rel/IndexScanNodeExecutionTest.java
@@ -32,16 +32,11 @@ import java.util.concurrent.Flow.Publisher;
 import java.util.concurrent.Flow.Subscriber;
 import java.util.concurrent.Flow.Subscription;
 import java.util.stream.Collectors;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelFieldCollation;
 import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeFactory.Builder;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.ignite.internal.index.ColumnCollation;
-import org.apache.ignite.internal.index.HashIndex;
-import org.apache.ignite.internal.index.Index;
-import org.apache.ignite.internal.index.IndexDescriptor;
-import org.apache.ignite.internal.index.SortedIndexDescriptor;
-import org.apache.ignite.internal.index.SortedIndexImpl;
 import org.apache.ignite.internal.schema.NativeTypes;
 import org.apache.ignite.internal.sql.engine.exec.ExecutionContext;
 import org.apache.ignite.internal.sql.engine.exec.RowHandler.RowFactory;
@@ -51,13 +46,14 @@ import org.apache.ignite.internal.sql.engine.exec.row.RowSchema;
 import org.apache.ignite.internal.sql.engine.metadata.PartitionWithTerm;
 import org.apache.ignite.internal.sql.engine.planner.AbstractPlannerTest.TestTableDescriptor;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
+import org.apache.ignite.internal.sql.engine.schema.IgniteIndex.Collation;
 import org.apache.ignite.internal.sql.engine.schema.TableDescriptor;
+import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
 import org.apache.ignite.internal.sql.engine.trait.IgniteDistributions;
+import org.apache.ignite.internal.sql.engine.trait.TraitUtils;
 import org.apache.ignite.internal.sql.engine.util.Commons;
-import org.apache.ignite.internal.table.InternalTable;
 import org.jetbrains.annotations.Nullable;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 
 /**
  * Test {@link IndexScanNode} execution.
@@ -69,7 +65,11 @@ public class IndexScanNodeExecutionTest extends AbstractExecutionTest {
      */
     @Test
     public void testSortedIndex() {
-        Index<?> index = newSortedIndex();
+        List<String> columns = List.of("C1");
+        List<Collation> collations = List.of(IgniteIndex.Collation.ASC_NULLS_LAST);
+
+        TableDescriptor tableDescriptor = createTableDescriptor(columns);
+        IgniteIndex indexDescriptor = createSortedIndexDescriptor(columns, collations, tableDescriptor);
 
         ExecutionContext<Object[]> ctx = executionContext();
 
@@ -81,7 +81,7 @@ public class IndexScanNodeExecutionTest extends AbstractExecutionTest {
 
         Comparator<Object[]> cmp = Comparator.comparing(row -> (Comparable<Object>) row[0]);
 
-        IndexScanNode<Object[]> node = tester.createSortedIndex(index, scannableTable, cmp);
+        IndexScanNode<Object[]> node = tester.createSortedIndex(indexDescriptor, tableDescriptor, scannableTable, cmp);
         List<Object[]> result = tester.execute(node);
 
         validateResult(result, List.of(new Object[]{1}, new Object[]{2}, new Object[]{4}, new Object[]{5}));
@@ -92,7 +92,10 @@ public class IndexScanNodeExecutionTest extends AbstractExecutionTest {
      */
     @Test
     public void testHashIndex() {
-        Index<?> index = newHashIndex();
+        List<String> columns = List.of("C1");
+
+        TableDescriptor tableDescriptor = createTableDescriptor(columns);
+        IgniteIndex indexDescriptor = createHashIndexDescriptor(columns, tableDescriptor);
 
         ExecutionContext<Object[]> ctx = executionContext();
 
@@ -102,13 +105,46 @@ public class IndexScanNodeExecutionTest extends AbstractExecutionTest {
         scannableTable.setPartitionData(0, new Object[]{2}, new Object[]{1});
         scannableTable.setPartitionData(2, new Object[]{0});
 
-        IndexScanNode<Object[]> node = tester.createHashIndex(index, scannableTable);
+        IndexScanNode<Object[]> node = tester.createHashIndex(indexDescriptor, tableDescriptor, scannableTable);
         List<Object[]> result = tester.execute(node);
 
         validateResult(result, List.of(new Object[]{2}, new Object[]{1}, new Object[]{0}));
     }
 
-    private class Tester {
+    private static TableDescriptor createTableDescriptor(List<String> columns) {
+        Builder rowTypeBuilder = new Builder(Commons.typeFactory());
+
+        for (String column : columns) {
+            rowTypeBuilder = rowTypeBuilder.add(column, SqlTypeName.INTEGER);
+        }
+
+        RelDataType rowType =  rowTypeBuilder.build();
+
+        return new TestTableDescriptor(IgniteDistributions::single, rowType);
+    }
+
+    private static IgniteIndex createHashIndexDescriptor(
+            List<String> columns,
+            TableDescriptor tableDescriptor
+    ) {
+        RelCollation collation = TraitUtils.createCollation(columns, null, tableDescriptor);
+        IgniteDistribution distribution = tableDescriptor.distribution();
+
+        return new IgniteIndex(1, "IDX", IgniteIndex.Type.HASH, distribution, collation);
+    }
+
+    private static IgniteIndex createSortedIndexDescriptor(
+            List<String> columns,
+            List<Collation> collations,
+            TableDescriptor tableDescriptor
+    ) {
+        RelCollation collation = TraitUtils.createCollation(columns, collations, tableDescriptor);
+        IgniteDistribution distribution = tableDescriptor.distribution();
+
+        return new IgniteIndex(1, "IDX", IgniteIndex.Type.HASH, distribution, collation);
+    }
+
+    private static class Tester {
 
         private final ExecutionContext<Object[]> ctx;
 
@@ -116,12 +152,14 @@ public class IndexScanNodeExecutionTest extends AbstractExecutionTest {
             this.ctx = ctx;
         }
 
-        IndexScanNode<Object[]> createSortedIndex(Index<?> index, TestScannableTable<?> scannableTable, Comparator<Object[]> cmp) {
-            return createIndexNode(ctx, index, scannableTable, cmp);
+        IndexScanNode<Object[]> createSortedIndex(IgniteIndex indexDescriptor, TableDescriptor tableDescriptor,
+                TestScannableTable<?> scannableTable, Comparator<Object[]> cmp) {
+            return createIndexNode(ctx, indexDescriptor, tableDescriptor, scannableTable, cmp);
         }
 
-        IndexScanNode<Object[]> createHashIndex(Index<?> index, TestScannableTable<?> scannableTable) {
-            return createIndexNode(ctx, index, scannableTable, null);
+        IndexScanNode<Object[]> createHashIndex(IgniteIndex desc, TableDescriptor tableDescriptor,
+                TestScannableTable<?> scannableTable) {
+            return createIndexNode(ctx, desc, tableDescriptor, scannableTable, null);
         }
 
         List<Object[]> execute(IndexScanNode<Object[]> indexNode) {
@@ -152,42 +190,22 @@ public class IndexScanNodeExecutionTest extends AbstractExecutionTest {
         }
     }
 
-    private Index<?> newHashIndex() {
-        IndexDescriptor descriptor = new IndexDescriptor("IDX", List.of("C1"));
-
-        return new HashIndex(1, Mockito.mock(InternalTable.class), descriptor);
-    }
-
-    private Index<?> newSortedIndex() {
-        List<String> columnNames = List.of("C1");
-        List<ColumnCollation> columnCollations = List.of(ColumnCollation.ASC_NULLS_LAST);
-        SortedIndexDescriptor descriptor = new SortedIndexDescriptor("IDX", columnNames, columnCollations);
+    private static IndexScanNode<Object[]> createIndexNode(ExecutionContext<Object[]> ctx, IgniteIndex indexDescriptor,
+            TableDescriptor tableDescriptor, TestScannableTable<?> scannableTable, @Nullable Comparator<Object[]> comparator) {
 
-        return new SortedIndexImpl(1, Mockito.mock(InternalTable.class), descriptor);
-    }
-
-    private IndexScanNode<Object[]> createIndexNode(ExecutionContext<Object[]> ctx, Index<?> index,
-            TestScannableTable<?> scannableTable, @Nullable Comparator<Object[]> comparator) {
-
-        RelDataTypeFactory.Builder rowTypeBuilder = new Builder(Commons.typeFactory());
         RowSchema.Builder rowSchemaBuilder = RowSchema.builder();
 
-        for (String column : index.descriptor().columns()) {
-            rowTypeBuilder = rowTypeBuilder.add(column, SqlTypeName.INTEGER);
+        for (RelFieldCollation fieldCollation : indexDescriptor.collation().getFieldCollations()) {
             rowSchemaBuilder = rowSchemaBuilder.addField(NativeTypes.INT32);
         }
 
-        RelDataType rowType = rowTypeBuilder.build();
         RowSchema rowSchema = rowSchemaBuilder.build();
 
-        TableDescriptor tableDescriptor = new TestTableDescriptor(IgniteDistributions::single, rowType);
-
-        IgniteIndex schemaIndex = new IgniteIndex(index);
         RowFactory<Object[]> rowFactory = ctx.rowHandler().factory(rowSchema);
         SingleRangeIterable<Object[]> conditions = new SingleRangeIterable<>(new Object[]{}, null, false, false);
         List<PartitionWithTerm> partitions = scannableTable.getPartitions();
 
-        return new IndexScanNode<>(ctx, rowFactory, schemaIndex, scannableTable, tableDescriptor, partitions,
+        return new IndexScanNode<>(ctx, rowFactory, indexDescriptor, scannableTable, tableDescriptor, partitions,
                 comparator, conditions, null, null, null);
     }
 
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 6c3448ba52..0628cd50a2 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
@@ -85,10 +85,4 @@ public class PredefinedSchemaManager implements SqlSchemaManager {
     public CompletableFuture<Void> schemaReadyFuture(int version) {
         return completedFuture(null);
     }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteTable tableById(int id) {
-        return tableById.get(id);
-    }
 }
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestBuilders.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestBuilders.java
index d38427b2a3..2f7c87be6b 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestBuilders.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestBuilders.java
@@ -33,7 +33,6 @@ import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-import org.apache.calcite.schema.Table;
 import org.apache.ignite.internal.schema.NativeType;
 import org.apache.ignite.internal.sql.engine.exec.ArrayRowHandler;
 import org.apache.ignite.internal.sql.engine.exec.ExecutionContext;
@@ -47,9 +46,9 @@ import org.apache.ignite.internal.sql.engine.schema.ColumnDescriptorImpl;
 import org.apache.ignite.internal.sql.engine.schema.DefaultValueStrategy;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex.Collation;
-import org.apache.ignite.internal.sql.engine.schema.IgniteIndex.Type;
 import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
 import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
+import org.apache.ignite.internal.sql.engine.schema.TableDescriptor;
 import org.apache.ignite.internal.sql.engine.schema.TableDescriptorImpl;
 import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
 import org.apache.ignite.internal.sql.engine.util.BaseQueryContext;
@@ -351,16 +350,11 @@ public class TestBuilders {
                 }
             }
 
-            Map<String, Table> tableMap = tableBuilders.stream()
+            Map<String, IgniteTable> tableMap = tableBuilders.stream()
                     .map(ClusterTableBuilderImpl::build)
                     .collect(Collectors.toMap(TestTable::name, Function.identity()));
 
-            Map<Integer, IgniteIndex> indexMap = tableMap.values().stream()
-                    .map(TestTable.class::cast)
-                    .flatMap(t -> t.indexes().values().stream().map(TestIndex.class::cast))
-                    .collect(Collectors.toMap(TestIndex::id, Function.identity()));
-
-            var schemaManager = new PredefinedSchemaManager(new IgniteSchema("PUBLIC", tableMap, indexMap, SCHEMA_VERSION));
+            var schemaManager = new PredefinedSchemaManager(new IgniteSchema("PUBLIC", SCHEMA_VERSION, tableMap.values()));
             var colocationGroupProvider = new TestColocationGroupProvider(tableBuilders, tableMap, nodeNames);
 
             Map<String, TestNode> nodes = nodeNames.stream()
@@ -430,15 +424,18 @@ public class TestBuilders {
                 throw new IllegalArgumentException("Table must contain at least one column");
             }
 
-            TestTable testTable = new TestTable(
-                    new TableDescriptorImpl(columns, distribution),
-                    Objects.requireNonNull(name),
-                    size
-            );
+            TableDescriptorImpl tableDescriptor = new TableDescriptorImpl(columns, distribution);
 
-            indexBuilders.stream().map(AbstractIndexBuilderImpl::build).forEach(testTable::addIndex);
+            List<IgniteIndex> indexMap = indexBuilders.stream()
+                    .map(idx -> idx.build(tableDescriptor))
+                    .collect(Collectors.toList());
 
-            return testTable;
+            return new TestTable(
+                    tableDescriptor,
+                    Objects.requireNonNull(name),
+                    size,
+                    indexMap
+            );
         }
 
         /** {@inheritDoc} */
@@ -482,11 +479,13 @@ public class TestBuilders {
         }
 
         private TestTable build() {
-            TestTable testTable = new TestTable(new TableDescriptorImpl(columns, distribution), name, dataProviders, size);
+            TableDescriptorImpl tableDescriptor = new TableDescriptorImpl(columns, distribution);
 
-            indexBuilders.forEach(idx -> testTable.addIndex(idx.build()));
+            List<IgniteIndex> indexes = indexBuilders.stream()
+                    .map(idx -> idx.build(tableDescriptor))
+                    .collect(Collectors.toList());
 
-            return testTable;
+            return new TestTable(tableDescriptor, name, size, indexes, dataProviders);
         }
     }
 
@@ -514,7 +513,7 @@ public class TestBuilders {
 
         /** {@inheritDoc} */
         @Override
-        public TestIndex build() {
+        public TestIndex build(TableDescriptor desc) {
             if (name == null) {
                 throw new IllegalArgumentException("Name is not specified");
             }
@@ -527,7 +526,7 @@ public class TestBuilders {
                 throw new IllegalArgumentException("Collation must be specified for each of columns.");
             }
 
-            return new TestIndex(name, Type.SORTED, columns, collations, dataProviders);
+            return TestIndex.createSorted(name, columns, collations, desc, dataProviders);
         }
     }
 
@@ -554,7 +553,7 @@ public class TestBuilders {
 
         /** {@inheritDoc} */
         @Override
-        public TestIndex build() {
+        public TestIndex build(TableDescriptor desc) {
             if (name == null) {
                 throw new IllegalArgumentException("Name is not specified");
             }
@@ -565,7 +564,7 @@ public class TestBuilders {
 
             assert collations == null : "Collation is not supported.";
 
-            return new TestIndex(name, Type.HASH, columns, null, dataProviders);
+            return TestIndex.createHash(name, columns, desc, dataProviders);
         }
     }
 
@@ -592,10 +591,10 @@ public class TestBuilders {
         }
 
         @Override
-        TestIndex build() {
+        TestIndex build(TableDescriptor desc) {
             assert collations.size() == columns.size();
 
-            return TestIndex.createSorted(name, columns, collations, dataProviders);
+            return TestIndex.createSorted(name, columns, collations, desc, dataProviders);
         }
     }
 
@@ -622,10 +621,10 @@ public class TestBuilders {
         }
 
         @Override
-        TestIndex build() {
+        TestIndex build(TableDescriptor desc) {
             assert collations == null;
 
-            return TestIndex.createHash(name, columns, dataProviders);
+            return TestIndex.createHash(name, columns, desc, dataProviders);
         }
     }
 
@@ -673,7 +672,7 @@ public class TestBuilders {
         @Override
         public ChildT addKeyColumn(String name, NativeType type) {
             columns.add(new ColumnDescriptorImpl(
-                    name, true, false, columns.size(), columns.size(), type, DefaultValueStrategy.DEFAULT_NULL, null
+                    name, true, false, columns.size(), type, DefaultValueStrategy.DEFAULT_NULL, null
             ));
 
             return self();
@@ -689,7 +688,7 @@ public class TestBuilders {
         @Override
         public ChildT addColumn(String name, NativeType type, boolean nullable) {
             columns.add(new ColumnDescriptorImpl(
-                    name, false, nullable, columns.size(), columns.size(), type, DefaultValueStrategy.DEFAULT_NULL, null
+                    name, false, nullable, columns.size(), type, DefaultValueStrategy.DEFAULT_NULL, null
             ));
 
             return self();
@@ -702,7 +701,7 @@ public class TestBuilders {
                 return addColumn(name, type);
             } else {
                 ColumnDescriptorImpl desc = new ColumnDescriptorImpl(
-                        name, false, true, columns.size(), columns.size(), type, DefaultValueStrategy.DEFAULT_CONSTANT, () -> defaultValue
+                        name, false, true, columns.size(), type, DefaultValueStrategy.DEFAULT_CONSTANT, () -> defaultValue
                 );
                 columns.add(desc);
             }
@@ -744,7 +743,7 @@ public class TestBuilders {
             return self();
         }
 
-        abstract TestIndex build();
+        abstract TestIndex build(TableDescriptor desc);
     }
 
     private abstract static class AbstractDataSourceBuilderImpl<ChildT> {
@@ -880,11 +879,11 @@ public class TestBuilders {
 
         private final Map<Integer, CompletableFuture<ColocationGroup>> groups = new HashMap<>();
 
-        TestColocationGroupProvider(List<ClusterTableBuilderImpl> tableBuilders, Map<String, Table> tableMap, List<String> nodeNames) {
+        TestColocationGroupProvider(List<ClusterTableBuilderImpl> tableBuilders, Map<String, IgniteTable> tableMap,
+                List<String> nodeNames) {
 
             for (ClusterTableBuilderImpl tableBuilder : tableBuilders) {
-                Table table = tableMap.get(tableBuilder.name);
-                IgniteTable igniteTable = (IgniteTable) table;
+                IgniteTable table = tableMap.get(tableBuilder.name);
                 CompletableFuture<ColocationGroup> f;
 
                 if (!tableBuilder.dataProviders.isEmpty()) {
@@ -896,7 +895,7 @@ public class TestBuilders {
                     f = CompletableFuture.completedFuture(ColocationGroup.forNodes(nodeNames));
                 }
 
-                groups.put(igniteTable.id(), f);
+                groups.put(table.id(), f);
             }
         }
 
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestIndex.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestIndex.java
index dd8449e6bb..139434f125 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestIndex.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestIndex.java
@@ -22,8 +22,11 @@ import static org.apache.ignite.lang.IgniteStringFormatter.format;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
+import org.apache.calcite.rel.RelCollation;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
-import org.jetbrains.annotations.Nullable;
+import org.apache.ignite.internal.sql.engine.schema.TableDescriptor;
+import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
+import org.apache.ignite.internal.sql.engine.trait.TraitUtils;
 
 /**
  * A test index that implements all the necessary for the optimizer methods to be used to prepare a query, as well as provides access to the
@@ -34,49 +37,47 @@ public class TestIndex extends IgniteIndex {
             "DataProvider is not configured [index={}, node={}]";
 
     /** Factory method for creating hash-index. */
-    static TestIndex createHash(String name, List<String> indexedColumns, Map<String, DataProvider<?>> dataProviders) {
-        return new TestIndex(name, Type.HASH, indexedColumns, null, dataProviders);
+    static TestIndex createHash(
+            String name,
+            List<String> columns,
+            TableDescriptor tableDescriptor,
+            Map<String, DataProvider<?>> dataProviders
+    ) {
+        RelCollation collation = TraitUtils.createCollation(columns, null, tableDescriptor);
+
+        return new TestIndex(name, Type.HASH, tableDescriptor.distribution(), collation, dataProviders);
     }
 
     /** Factory method for creating sorted-index. */
-    static TestIndex createSorted(String name, List<String> columns, List<Collation> collations,
-            Map<String, DataProvider<?>> dataProviders) {
-        return new TestIndex(name, Type.SORTED, columns, collations, dataProviders);
+    static TestIndex createSorted(
+            String name,
+            List<String> columns,
+            List<Collation> collations,
+            TableDescriptor tableDescriptor,
+            Map<String, DataProvider<?>> dataProviders
+    ) {
+        RelCollation collation = TraitUtils.createCollation(columns, collations, tableDescriptor);
+
+        return new TestIndex(name, Type.SORTED, tableDescriptor.distribution(), collation, dataProviders);
     }
 
     private static final AtomicInteger ID = new AtomicInteger();
 
-    private final int id = ID.incrementAndGet();
-    private final String name;
-
     private final Map<String, DataProvider<?>> dataProviders;
 
     /** Constructor. */
     TestIndex(
             String name,
             Type type,
-            List<String> columns,
-            @Nullable List<Collation> collations,
+            IgniteDistribution distribution,
+            RelCollation collation,
             Map<String, DataProvider<?>> dataProviders
     ) {
-        super(type, columns, collations);
+        super(ID.incrementAndGet(), name, type, distribution, collation);
 
-        this.name = name;
         this.dataProviders = dataProviders;
     }
 
-    /** Returns an id of the index. */
-    @Override
-    public int id() {
-        return id;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public String name() {
-        return name;
-    }
-
     /**
      * Returns the data provider for the given node.
      *
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 3eaa2abc2d..04f39c6cdc 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
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.sql.engine.framework;
 
+import static org.apache.ignite.internal.catalog.CatalogService.DEFAULT_SCHEMA_NAME;
 import static org.apache.ignite.internal.sql.engine.exec.ExecutionServiceImplTest.PLANNING_TIMEOUT;
 import static org.apache.ignite.internal.sql.engine.util.Commons.FRAMEWORK_CONFIG;
 import static org.apache.ignite.internal.testframework.IgniteTestUtils.await;
@@ -27,9 +28,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 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;
@@ -61,6 +60,7 @@ import org.apache.ignite.internal.sql.engine.prepare.QueryPlan;
 import org.apache.ignite.internal.sql.engine.prepare.ddl.DdlSqlToCommandConverter;
 import org.apache.ignite.internal.sql.engine.rel.IgniteIndexScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan;
+import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
 import org.apache.ignite.internal.sql.engine.schema.SqlSchemaManager;
 import org.apache.ignite.internal.sql.engine.sql.ParsedResult;
 import org.apache.ignite.internal.sql.engine.sql.ParserService;
@@ -81,7 +81,7 @@ import org.apache.ignite.network.TopologyService;
  */
 public class TestNode implements LifecycleAware {
     private final String nodeName;
-    private final SchemaPlus schema;
+    private final SqlSchemaManager schemaManager;
     private final PrepareService prepareService;
     private final ExecutionService executionService;
     private final ParserService parserService;
@@ -104,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(CatalogService.DEFAULT_SCHEMA_NAME, -1);
+        this.schemaManager = schemaManager;
 
         TopologyService topologyService = clusterService.topologyService();
         MessagingService messagingService = clusterService.messagingService();
@@ -134,7 +134,7 @@ public class TestNode implements LifecycleAware {
                 dependencyResolver,
                 (ctx, deps) -> new LogicalRelImplementor<Object[]>(
                         ctx,
-                        new HashFunctionFactoryImpl<>(schemaManager, rowHandler),
+                        new HashFunctionFactoryImpl<>(ctx.getRootSchema().unwrap(IgniteSchema.class), rowHandler),
                         mailboxRegistry,
                         exchangeService,
                         deps
@@ -149,7 +149,7 @@ public class TestNode implements LifecycleAware {
                     @Override
                     public Node<Object[]> visit(IgniteIndexScan rel) {
                         TestTable tbl = rel.getTable().unwrap(TestTable.class);
-                        TestIndex idx = (TestIndex) tbl.getIndex(rel.indexName());
+                        TestIndex idx = (TestIndex) tbl.indexes().get(rel.indexName());
 
                         DataProvider<Object[]> dataProvider = idx.dataProvider(ctx.localNode().name());
 
@@ -226,7 +226,7 @@ public class TestNode implements LifecycleAware {
                 .cancel(new QueryCancel())
                 .frameworkConfig(
                         Frameworks.newConfigBuilder(FRAMEWORK_CONFIG)
-                                .defaultSchema(schema)
+                                .defaultSchema(schemaManager.schema(DEFAULT_SCHEMA_NAME, Long.MAX_VALUE))
                                 .build()
                 )
                 .build();
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestTable.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestTable.java
index db7c1ff202..38bf9d4e8b 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestTable.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestTable.java
@@ -19,11 +19,11 @@ package org.apache.ignite.internal.sql.engine.framework;
 
 import static org.apache.ignite.lang.IgniteStringFormatter.format;
 
-import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 import org.apache.calcite.config.CalciteConnectionConfig;
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptTable;
@@ -36,7 +36,6 @@ import org.apache.calcite.schema.Statistic;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
 import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
@@ -56,7 +55,7 @@ public class TestTable implements IgniteTable {
     private static final AtomicInteger ID = new AtomicInteger();
 
     private final int id = ID.incrementAndGet();
-    private final Map<String, IgniteIndex> indexes = new HashMap<>();
+    private final Map<String, IgniteIndex> indexes;
 
     private final String name;
     private final double rowCnt;
@@ -68,26 +67,25 @@ public class TestTable implements IgniteTable {
     public TestTable(
             TableDescriptor descriptor,
             String name,
-            double rowCnt
+            double rowCnt,
+            List<IgniteIndex> indexes
     ) {
-        this.descriptor = descriptor;
-        this.name = name;
-        this.rowCnt = rowCnt;
-
-        dataProviders = Collections.emptyMap();
+        this(descriptor, name, rowCnt, indexes, Map.of());
     }
 
     /** Constructor. */
     public TestTable(
             TableDescriptor descriptor,
             String name,
-            Map<String, DataProvider<?>> dataProviders,
-            double rowCnt
+            double rowCnt,
+            List<IgniteIndex> indexList,
+            Map<String, DataProvider<?>> dataProviders
     ) {
         this.descriptor = descriptor;
         this.name = name;
         this.rowCnt = rowCnt;
         this.dataProviders = dataProviders;
+        indexes = indexList.stream().collect(Collectors.toUnmodifiableMap(IgniteIndex::name, Function.identity()));
     }
 
     /**
@@ -131,19 +129,6 @@ public class TestTable implements IgniteTable {
         return IgniteLogicalTableScan.create(cluster, cluster.traitSet(), hints, relOptTbl, proj, cond, requiredColumns);
     }
 
-    /** {@inheritDoc} */
-    @Override
-    public IgniteLogicalIndexScan toRel(
-            RelOptCluster cluster,
-            RelOptTable relOptTbl,
-            String idxName,
-            @Nullable List<RexNode> proj,
-            @Nullable RexNode cond,
-            @Nullable ImmutableBitSet requiredColumns
-    ) {
-        return IgniteLogicalIndexScan.create(cluster, cluster.traitSet(), relOptTbl, idxName, proj, cond, requiredColumns);
-    }
-
     /** {@inheritDoc} */
     @Override
     public RelDataType getRowType(RelDataTypeFactory typeFactory, ImmutableBitSet bitSet) {
@@ -194,25 +179,7 @@ public class TestTable implements IgniteTable {
     /** {@inheritDoc} */
     @Override
     public Map<String, IgniteIndex> indexes() {
-        return Collections.unmodifiableMap(indexes);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public void addIndex(IgniteIndex idxTbl) {
-        indexes.put(idxTbl.name(), idxTbl);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteIndex getIndex(String idxName) {
-        return indexes.get(idxName);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public void removeIndex(String idxName) {
-        throw new AssertionError();
+        return indexes;
     }
 
     /** {@inheritDoc} */
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/AbstractPlannerTest.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/AbstractPlannerTest.java
index 7df6627236..3962c4cdd6 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/AbstractPlannerTest.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/AbstractPlannerTest.java
@@ -75,6 +75,7 @@ import org.apache.calcite.sql2rel.InitializerContext;
 import org.apache.calcite.sql2rel.SqlToRelConverter;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.Util;
+import org.apache.ignite.internal.catalog.CatalogService;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.index.ColumnCollation;
 import org.apache.ignite.internal.index.Index;
@@ -616,13 +617,18 @@ public abstract class AbstractPlannerTest extends IgniteAbstractTest {
      * @return Public schema.
      */
     protected static IgniteSchema createSchema(IgniteTable... tbls) {
-        IgniteSchema schema = new IgniteSchema("PUBLIC");
-
-        for (IgniteTable tbl : tbls) {
-            schema.addTable(tbl);
-        }
+        return createSchema(CatalogService.DEFAULT_SCHEMA_NAME, tbls);
+    }
 
-        return schema;
+    /**
+     * Creates schema with given name from provided tables.
+     *
+     * @param schemaName Schema name.
+     * @param tbls Tables to create schema for.
+     * @return Schema with given name.
+     */
+    protected static IgniteSchema createSchema(String schemaName, IgniteTable... tbls) {
+        return new IgniteSchema(schemaName, 0, Arrays.asList(tbls));
     }
 
     protected void checkSplitAndSerialization(IgniteRel rel, IgniteSchema publicSchema) {
@@ -700,7 +706,7 @@ public abstract class AbstractPlannerTest extends IgniteAbstractTest {
                         return false;
                     }
 
-                    if (!idxName.equals(n.indexName())) {
+                    if (!idxName.equalsIgnoreCase(n.indexName())) {
                         lastErrorMsg = "Unexpected index name [exp=" + idxName + ", act=" + n.indexName() + ']';
 
                         return false;
@@ -860,12 +866,6 @@ public abstract class AbstractPlannerTest extends IgniteAbstractTest {
             return idx;
         }
 
-        /** {@inheritDoc} */
-        @Override
-        public int physicalIndex() {
-            return idx;
-        }
-
         /** {@inheritDoc} */
         @Override
         public NativeType physicalType() {
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/IndexSearchBoundsPlannerTest.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/IndexSearchBoundsPlannerTest.java
index b4d7ed7fe2..4407152be8 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/IndexSearchBoundsPlannerTest.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/IndexSearchBoundsPlannerTest.java
@@ -180,11 +180,6 @@ public class IndexSearchBoundsPlannerTest extends AbstractPlannerTest {
                         .addColumn("C4", Collation.DESC_NULLS_LAST)
                         .addColumn("C3", Collation.ASC_NULLS_FIRST)
                         .end())
-                .andThen(t -> t.sortedIndex()
-                        .name("C4_IDX")
-                        .addColumn("C4", Collation.ASC_NULLS_FIRST)
-                        .addColumn("C3", Collation.ASC_NULLS_FIRST)
-                        .end())
         );
 
         assertBounds("SELECT * FROM TEST WHERE C4 > 1",
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/JoinWithUsingPlannerTest.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/JoinWithUsingPlannerTest.java
index b527352070..b86d7edc8f 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/JoinWithUsingPlannerTest.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/JoinWithUsingPlannerTest.java
@@ -21,7 +21,6 @@ import java.util.ArrayList;
 import java.util.Collection;
 import org.apache.ignite.internal.schema.NativeTypes;
 import org.apache.ignite.internal.sql.engine.framework.TestBuilders;
-import org.apache.ignite.internal.sql.engine.framework.TestTable;
 import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
 import org.apache.ignite.internal.sql.engine.trait.IgniteDistributions;
 import org.junit.jupiter.api.BeforeAll;
@@ -64,16 +63,6 @@ public class JoinWithUsingPlannerTest extends AbstractPlannerTest {
         schemas.add(otherSchema);
     }
 
-    private static IgniteSchema createSchema(String schemaName, TestTable... tables) {
-        IgniteSchema schema = new IgniteSchema(schemaName);
-
-        for (TestTable table : tables) {
-            schema.addTable(table);
-        }
-
-        return schema;
-    }
-
     @Test
     public void testJoinWithUsing() throws Exception {
         // Join tables without aliases.
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/TypeCoercionTest.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/TypeCoercionTest.java
index 161dee6bd0..e15a52e0eb 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/TypeCoercionTest.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/TypeCoercionTest.java
@@ -58,7 +58,6 @@ import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.ignite.internal.sql.engine.framework.TestStatistic;
 import org.apache.ignite.internal.sql.engine.planner.AbstractPlannerTest;
-import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan;
 import org.apache.ignite.internal.sql.engine.schema.IgniteIndex;
 import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
@@ -602,18 +601,6 @@ public class TypeCoercionTest extends AbstractPlannerTest {
             return IgniteLogicalTableScan.create(cluster, cluster.traitSet(), hints, relOptTbl, proj, cond, requiredColumns);
         }
 
-        @Override
-        public IgniteLogicalIndexScan toRel(
-                RelOptCluster cluster,
-                RelOptTable relOptTbl,
-                String idxName,
-                @Nullable List<RexNode> proj,
-                @Nullable RexNode cond,
-                @Nullable ImmutableBitSet requiredColumns
-        ) {
-            return IgniteLogicalIndexScan.create(cluster, cluster.traitSet(), relOptTbl, idxName, proj, cond, requiredColumns);
-        }
-
         /** {@inheritDoc} */
         @Override
         public RelDataType getRowType(RelDataTypeFactory typeFactory, ImmutableBitSet bitSet) {
@@ -665,21 +652,6 @@ public class TypeCoercionTest extends AbstractPlannerTest {
             return Map.of();
         }
 
-        @Override
-        public void addIndex(IgniteIndex idxTbl) {
-            throw new AssertionError();
-        }
-
-        @Override
-        public IgniteIndex getIndex(String idxName) {
-            throw new AssertionError();
-        }
-
-        @Override
-        public void removeIndex(String idxName) {
-            throw new AssertionError();
-        }
-
         @Override
         public String name() {
             return name;
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 5992794c9e..e07eaa7a5b 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
@@ -100,7 +100,7 @@ public class CatalogSqlSchemaManagerTest {
 
         SqlSchemaManager sqlSchemaManager = newSchemaManager();
         SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
-        IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+        IgniteSchema schema = unwrapSchema(schemaPlus);
 
         assertEquals(testSchema.name, schema.getName());
         assertEquals(testSchema.version, schema.version());
@@ -157,7 +157,7 @@ public class CatalogSqlSchemaManagerTest {
 
         SqlSchemaManager sqlSchemaManager = newSchemaManager();
         SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
-        IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+        IgniteSchema schema = unwrapSchema(schemaPlus);
 
         IgniteSchemaTable table = getTable(schema, testTable);
 
@@ -168,12 +168,10 @@ public class CatalogSqlSchemaManagerTest {
 
         ColumnDescriptor c1 = table.descriptor().columnDescriptor(0);
         assertEquals(0, c1.logicalIndex());
-        assertEquals(0, c1.physicalIndex());
         assertTrue(c1.nullable());
 
         ColumnDescriptor c2 = table.descriptor().columnDescriptor(1);
         assertEquals(1, c2.logicalIndex());
-        assertEquals(1, c2.physicalIndex());
         assertFalse(c2.nullable());
 
         if (hasNativeType) {
@@ -198,7 +196,7 @@ public class CatalogSqlSchemaManagerTest {
 
         {
             SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
-            IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+            IgniteSchema schema = unwrapSchema(schemaPlus);
 
             assertEquals(DEFAULT_SCHEMA_NAME, schema.getName());
             assertEquals(testSchema.version, schema.version());
@@ -206,7 +204,7 @@ public class CatalogSqlSchemaManagerTest {
 
         {
             SchemaPlus schemaPlus = sqlSchemaManager.schema(null, testSchema.timestamp);
-            IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+            IgniteSchema schema = unwrapSchema(schemaPlus);
 
             assertEquals(DEFAULT_SCHEMA_NAME, schema.getName());
             assertEquals(testSchema.version, schema.version());
@@ -235,7 +233,7 @@ public class CatalogSqlSchemaManagerTest {
 
         SqlSchemaManager sqlSchemaManager = newSchemaManager();
         SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
-        IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+        IgniteSchema schema = unwrapSchema(schemaPlus);
 
         IgniteTable table = getTable(schema, testTable);
 
@@ -275,7 +273,7 @@ public class CatalogSqlSchemaManagerTest {
 
         SqlSchemaManager sqlSchemaManager = newSchemaManager();
         SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
-        IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+        IgniteSchema schema = unwrapSchema(schemaPlus);
 
         IgniteTable table = (IgniteTable) schema.getTable(testTable.name);
         assertNotNull(table);
@@ -303,7 +301,7 @@ public class CatalogSqlSchemaManagerTest {
 
         SqlSchemaManager sqlSchemaManager = newSchemaManager();
         SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
-        IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+        IgniteSchema schema = unwrapSchema(schemaPlus);
 
         IgniteTable table = (IgniteTable) schema.getTable(testTable.name);
         assertNotNull(table);
@@ -337,7 +335,7 @@ public class CatalogSqlSchemaManagerTest {
 
         SqlSchemaManager sqlSchemaManager = newSchemaManager();
         SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
-        IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+        IgniteSchema schema = unwrapSchema(schemaPlus);
 
         IgniteTable table = (IgniteTable) schema.getTable(testTable.name);
         assertNotNull(table);
@@ -370,12 +368,12 @@ public class CatalogSqlSchemaManagerTest {
 
         SqlSchemaManager sqlSchemaManager = newSchemaManager();
         SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
-        IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+        IgniteSchema schema = unwrapSchema(schemaPlus);
 
         IgniteSchemaTable table = (IgniteSchemaTable) schema.getTable(testTable.name);
         assertNotNull(table);
 
-        IgniteSchemaIndex testIdx = table.getIndexes().get(testIndex.name);
+        IgniteIndex testIdx = table.indexes().get(testIndex.name);
 
         assertEquals(testIndex.name, testIdx.name());
         assertEquals(Type.HASH, testIdx.type());
@@ -414,12 +412,12 @@ public class CatalogSqlSchemaManagerTest {
 
         SqlSchemaManager sqlSchemaManager = newSchemaManager();
         SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
-        IgniteCatalogSchema schema = unwrapSchema(schemaPlus);
+        IgniteSchema schema = unwrapSchema(schemaPlus);
 
         IgniteSchemaTable table = (IgniteSchemaTable) schema.getTable(testTable.name);
         assertNotNull(table);
 
-        IgniteSchemaIndex testIdx = table.getIndexes().get(testIndex.name);
+        IgniteIndex testIdx = table.indexes().get(testIndex.name);
 
         assertEquals(testIndex.name, testIdx.name());
         assertEquals(Type.SORTED, testIdx.type());
@@ -435,13 +433,13 @@ public class CatalogSqlSchemaManagerTest {
         return new CatalogSqlSchemaManager(catalogManager, 200);
     }
 
-    private IgniteCatalogSchema unwrapSchema(SchemaPlus schemaPlus) {
-        IgniteCatalogSchema igniteSchema = schemaPlus.unwrap(IgniteCatalogSchema.class);
+    private IgniteSchema unwrapSchema(SchemaPlus schemaPlus) {
+        IgniteSchema igniteSchema = schemaPlus.unwrap(IgniteSchema.class);
         assertNotNull(igniteSchema);
         return igniteSchema;
     }
 
-    private static IgniteSchemaTable getTable(IgniteCatalogSchema schema, TestTable testTable) {
+    private static IgniteSchemaTable getTable(IgniteSchema schema, TestTable testTable) {
         IgniteTable table = (IgniteTable) schema.getTable(testTable.name);
         assertNotNull(table);
         return (IgniteSchemaTable) table;
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/util/StatementChecker.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/util/StatementChecker.java
index 15b15816a5..b7f4b10f5a 100644
--- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/util/StatementChecker.java
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/util/StatementChecker.java
@@ -20,6 +20,7 @@ package org.apache.ignite.internal.sql.engine.util;
 import static org.apache.ignite.lang.IgniteStringFormatter.format;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -45,6 +46,7 @@ import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteValues;
 import org.apache.ignite.internal.sql.engine.rel.ProjectableFilterableTableScan;
 import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
+import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
 import org.apache.ignite.internal.sql.engine.trait.IgniteDistributions;
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Description;
@@ -89,7 +91,6 @@ import org.opentest4j.AssertionFailedError;
  * </pre>
  *
  * <p><b>Schema initialization</b>
- * Tables can be added to schema via {@code table} methods and initial schema can be set via {@link #withSchema(Consumer)} method.
  *
  * <pre>
  *     new StatementChecker()
@@ -116,8 +117,6 @@ public class StatementChecker {
 
     private boolean dumpPlan;
 
-    private Consumer<IgniteSchema> initSchema = (schema) -> {};
-
     private Consumer<StatementChecker> setup = (checker) -> {};
 
     private BiFunction<String, RelNode, String> planToString = (header, plan) -> {
@@ -150,12 +149,6 @@ public class StatementChecker {
         return this;
     }
 
-    /** Sets a function that initializes initial schema. */
-    public StatementChecker withSchema(Consumer<IgniteSchema> initSchema) {
-        this.initSchema = initSchema;
-        return this;
-    }
-
     /**
      * Updates schema to include a table with 1 column.
      */
@@ -206,7 +199,7 @@ public class StatementChecker {
             String col3, NativeType type3) {
 
         testTables.put(tableName, table -> {
-            return table.name(tableName.toUpperCase(Locale.US))
+            return table.name(tableName)
                     .addColumn(col1.toUpperCase(Locale.US), type1)
                     .addColumn(col2.toUpperCase(Locale.US), type2)
                     .addColumn(col3.toUpperCase(Locale.US), type3)
@@ -376,16 +369,17 @@ public class StatementChecker {
     }
 
     private IgniteSchema createSchema() {
-        IgniteSchema schema = new IgniteSchema("PUBLIC");
-        this.initSchema.accept(schema);
+        List<IgniteTable> tables = new ArrayList<>();
         for (Map.Entry<String, Function<TestBuilders.TableBuilder, TestTable>> entry : testTables.entrySet()) {
             String tableName = entry.getKey();
             Function<TableBuilder, TestTable> addTable = entry.getValue();
 
             TestTable table = addTable.apply(TestBuilders.table().name(tableName));
-            schema.addTable(table);
+
+            tables.add(table);
         }
-        return schema;
+
+        return new IgniteSchema("PUBLIC", 0, tables);
     }
 
     private DynamicTest shouldPass(String name, Throwable exception, Consumer<IgniteRel> check, boolean relCheck) {
diff --git a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractIndexStorageTest.java b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractIndexStorageTest.java
index 058205dedf..a158316da6 100644
--- a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractIndexStorageTest.java
+++ b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractIndexStorageTest.java
@@ -99,8 +99,8 @@ public abstract class AbstractIndexStorageTest<S extends IndexStorage, D extends
                 columnParamsBuilder(ColumnType.UUID).nullable(true).build(),
                 columnParamsBuilder(ColumnType.DATE).nullable(true).build(),
                 columnParamsBuilder(ColumnType.BITMASK).length(32).nullable(true).build(),
-                columnParamsBuilder(ColumnType.STRING).length(0).nullable(true).build(),
-                columnParamsBuilder(ColumnType.BYTE_ARRAY).length(0).nullable(true).build(),
+                columnParamsBuilder(ColumnType.STRING).nullable(true).build(),
+                columnParamsBuilder(ColumnType.BYTE_ARRAY).nullable(true).build(),
                 columnParamsBuilder(ColumnType.NUMBER).precision(Integer.MAX_VALUE).nullable(true).build(),
                 columnParamsBuilder(ColumnType.DECIMAL).precision(19).scale(3).nullable(true).build(),
                 columnParamsBuilder(ColumnType.TIME).precision(0).nullable(true).build(),