You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by zs...@apache.org on 2023/09/27 11:11:19 UTC

[ignite-3] branch main updated: IGNITE-20020: Sql. Support system views in planner. (#2601)

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

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


The following commit(s) were added to refs/heads/main by this push:
     new 11703c366f IGNITE-20020: Sql. Support system views in planner. (#2601)
11703c366f is described below

commit 11703c366fa3bed7c420cb894a0f4f92038197d2
Author: Max Zhuravkov <sh...@gmail.com>
AuthorDate: Wed Sep 27 14:11:12 2023 +0300

    IGNITE-20020: Sql. Support system views in planner. (#2601)
---
 .../sql/engine/exec/LogicalRelImplementor.java     |   7 +
 .../sql/engine/metadata/IgniteFragmentMapping.java |   6 +
 .../sql/engine/metadata/IgniteMdDistribution.java  |   4 +-
 .../sql/engine/prepare/IgniteRelShuttle.java       |   7 +
 .../engine/prepare/IgniteSqlToRelConvertor.java    |   4 +-
 .../sql/engine/prepare/IgniteSqlValidator.java     |  78 +++----
 .../internal/sql/engine/prepare/PlannerPhase.java  |   5 +
 .../internal/sql/engine/rel/IgniteRelVisitor.java  |   5 +
 .../sql/engine/rel/IgniteSystemViewScan.java       | 130 ++++++++++++
 .../engine/rel/ProjectableFilterableTableScan.java |   5 +-
 .../engine/rel/logical/IgniteLogicalIndexScan.java |   3 +-
 ...eScan.java => IgniteLogicalSystemViewScan.java} |  49 ++---
 .../engine/rel/logical/IgniteLogicalTableScan.java |   3 +-
 .../sql/engine/rule/LogicalScanConverterRule.java  |  46 ++++-
 .../engine/rule/logical/FilterScanMergeRule.java   |  31 +++
 .../engine/rule/logical/ProjectScanMergeRule.java  |  52 ++++-
 ...ableImpl.java => AbstractIgniteDataSource.java} |  54 ++---
 .../sql/engine/schema/CatalogSqlSchemaManager.java | 154 +++++++++-----
 .../sql/engine/schema/IgniteDataSource.java        |  81 ++++++++
 .../internal/sql/engine/schema/IgniteSchema.java   |  16 +-
 .../sql/engine/schema/IgniteSystemView.java        |  25 +++
 .../sql/engine/schema/IgniteSystemViewImpl.java    |  61 ++++++
 .../internal/sql/engine/schema/IgniteTable.java    | 140 +------------
 .../sql/engine/schema/IgniteTableImpl.java         | 141 +------------
 .../internal/sql/engine/util/IgniteResource.java   |   4 +
 .../sql/engine/exec/ExecutionServiceImplTest.java  |  20 +-
 .../internal/sql/engine/framework/TestTable.java   | 120 +----------
 .../sql/engine/planner/AbstractPlannerTest.java    |  19 ++
 .../sql/engine/planner/SystemViewPlannerTest.java  | 172 ++++++++++++++++
 .../sql/engine/prepare/TypeCoercionTest.java       |  34 ++--
 .../engine/schema/CatalogSqlSchemaManagerTest.java | 224 ++++++++++++++++-----
 31 files changed, 1061 insertions(+), 639 deletions(-)

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 b1de8f86a6..00a02b1fbc 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
@@ -89,6 +89,7 @@ import org.apache.ignite.internal.sql.engine.rel.IgniteRelVisitor;
 import org.apache.ignite.internal.sql.engine.rel.IgniteSender;
 import org.apache.ignite.internal.sql.engine.rel.IgniteSort;
 import org.apache.ignite.internal.sql.engine.rel.IgniteSortedIndexSpool;
+import org.apache.ignite.internal.sql.engine.rel.IgniteSystemViewScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableFunctionScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableModify;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan;
@@ -427,6 +428,12 @@ public class LogicalRelImplementor<RowT> implements IgniteRelVisitor<Node<RowT>>
         );
     }
 
+    /** {@inheritDoc} */
+    @Override
+    public Node<RowT> visit(IgniteSystemViewScan rel) {
+        throw new UnsupportedOperationException("System view scan is not implemented");
+    }
+
     /** {@inheritDoc} */
     @Override
     public Node<RowT> visit(IgniteValues rel) {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/metadata/IgniteFragmentMapping.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/metadata/IgniteFragmentMapping.java
index 56cb1ef3b8..4bb0d9cc25 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/metadata/IgniteFragmentMapping.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/metadata/IgniteFragmentMapping.java
@@ -42,6 +42,7 @@ import org.apache.ignite.internal.sql.engine.rel.IgniteRelVisitor;
 import org.apache.ignite.internal.sql.engine.rel.IgniteSender;
 import org.apache.ignite.internal.sql.engine.rel.IgniteSort;
 import org.apache.ignite.internal.sql.engine.rel.IgniteSortedIndexSpool;
+import org.apache.ignite.internal.sql.engine.rel.IgniteSystemViewScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableFunctionScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableModify;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan;
@@ -144,6 +145,11 @@ public class IgniteFragmentMapping implements IgniteRelVisitor<FragmentMapping>
         return mapTableScan(rel);
     }
 
+    @Override
+    public FragmentMapping visit(IgniteSystemViewScan rel) {
+        throw new UnsupportedOperationException("System view scan is not implemented");
+    }
+
     @Override
     public FragmentMapping visit(IgniteReceiver rel) {
         return mapReceiver(rel);
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/metadata/IgniteMdDistribution.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/metadata/IgniteMdDistribution.java
index 0fd993679e..0e9ea33748 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/metadata/IgniteMdDistribution.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/metadata/IgniteMdDistribution.java
@@ -30,7 +30,7 @@ import org.apache.calcite.rel.metadata.RelMetadataProvider;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.util.BuiltInMethod;
 import org.apache.ignite.internal.sql.engine.rel.IgniteRel;
-import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
+import org.apache.ignite.internal.sql.engine.schema.IgniteDataSource;
 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;
@@ -75,7 +75,7 @@ public class IgniteMdDistribution implements MetadataHandler<BuiltInMetadata.Dis
      * See {@link IgniteMdDistribution#distribution(RelNode, RelMetadataQuery)}.
      */
     public IgniteDistribution distribution(TableScan rel, RelMetadataQuery mq) {
-        return rel.getTable().unwrap(IgniteTable.class).distribution();
+        return rel.getTable().unwrap(IgniteDataSource.class).distribution();
     }
 
     /**
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteRelShuttle.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteRelShuttle.java
index bb252fbd72..8ff0c846f6 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteRelShuttle.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteRelShuttle.java
@@ -33,6 +33,7 @@ import org.apache.ignite.internal.sql.engine.rel.IgniteRelVisitor;
 import org.apache.ignite.internal.sql.engine.rel.IgniteSender;
 import org.apache.ignite.internal.sql.engine.rel.IgniteSort;
 import org.apache.ignite.internal.sql.engine.rel.IgniteSortedIndexSpool;
+import org.apache.ignite.internal.sql.engine.rel.IgniteSystemViewScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableFunctionScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableModify;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan;
@@ -174,6 +175,12 @@ public class IgniteRelShuttle implements IgniteRelVisitor<IgniteRel> {
         return processNode(rel);
     }
 
+    /** {@inheritDoc} */
+    @Override
+    public IgniteRel visit(IgniteSystemViewScan rel) {
+        return processNode(rel);
+    }
+
     /** {@inheritDoc} */
     @Override
     public IgniteRel visit(IgniteReceiver rel) {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlToRelConvertor.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlToRelConvertor.java
index 1c6da0767a..c7649bd149 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlToRelConvertor.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlToRelConvertor.java
@@ -53,7 +53,7 @@ import org.apache.calcite.sql2rel.SqlToRelConverter;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.util.ControlFlowException;
 import org.apache.calcite.util.Pair;
-import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
+import org.apache.ignite.internal.sql.engine.schema.IgniteDataSource;
 import org.jetbrains.annotations.Nullable;
 
 /** Converts a SQL parse tree into a relational algebra operators. */
@@ -137,7 +137,7 @@ public class IgniteSqlToRelConvertor extends SqlToRelConverter {
         RelOptTable targetTable = getTargetTable(insertOp);
         assert targetTable != null;
 
-        IgniteTable ignTable = targetTable.unwrap(IgniteTable.class);
+        IgniteDataSource ignTable = targetTable.unwrap(IgniteDataSource.class);
 
         List<RelDataTypeField> tblFields = targetTable.getRowType().getFieldList();
         List<String> targetFields = targetRowType.getFieldNames();
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlValidator.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlValidator.java
index ba7589d379..98b5210bda 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlValidator.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlValidator.java
@@ -65,6 +65,8 @@ import org.apache.calcite.sql.validate.SqlValidatorNamespace;
 import org.apache.calcite.sql.validate.SqlValidatorScope;
 import org.apache.calcite.sql.validate.SqlValidatorTable;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
+import org.apache.ignite.internal.sql.engine.schema.IgniteDataSource;
+import org.apache.ignite.internal.sql.engine.schema.IgniteSystemView;
 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.type.IgniteCustomType;
@@ -151,8 +153,11 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
     /** {@inheritDoc} */
     @Override
     public void validateInsert(SqlInsert insert) {
+        SqlValidatorTable table = table(validatedNamespace(insert, unknownType));
+        IgniteTable igniteTable = getIgniteTableForModification((SqlIdentifier) insert.getTargetTable(), table);
+
         if (insert.getTargetColumnList() == null) {
-            insert.setOperand(3, inferColumnList(insert));
+            insert.setOperand(3, inferColumnList(igniteTable));
         }
 
         super.validateInsert(insert);
@@ -190,6 +195,27 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
         }
     }
 
+    private IgniteTable getTableForModification(SqlIdentifier identifier) {
+        SqlValidatorTable table = getCatalogReader().getTable(identifier.names);
+
+        if (table == null) {
+            throw newValidationError(identifier, RESOURCE.objectNotFound(identifier.toString()));
+        }
+
+        return getIgniteTableForModification(identifier, table);
+    }
+
+    private IgniteTable getIgniteTableForModification(SqlIdentifier identifier, SqlValidatorTable table) {
+        IgniteDataSource dataSource = table.unwrap(IgniteDataSource.class);
+        assert dataSource != null;
+
+        if (dataSource instanceof IgniteSystemView) {
+            throw newValidationError(identifier, IgniteResource.INSTANCE.systemViewIsNotModifiable(identifier.toString()));
+        }
+
+        return (IgniteTable) dataSource;
+    }
+
     private static void syncSelectList(SqlSelect select, SqlUpdate update) {
         //
         // If a table has N columns and update::SourceExpressionList has size = M
@@ -221,16 +247,14 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
     protected SqlSelect createSourceSelectForUpdate(SqlUpdate call) {
         final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
         final SqlIdentifier targetTable = (SqlIdentifier) call.getTargetTable();
-        final SqlValidatorTable table = getCatalogReader().getTable(targetTable.names);
 
-        if (table == null) {
-            throw newValidationError(call.getTargetTable(), RESOURCE.objectNotFound(targetTable.toString()));
-        }
+        IgniteTable igniteTable = getTableForModification(targetTable);
+        TableDescriptor descriptor = igniteTable.descriptor();
 
         SqlIdentifier alias = call.getAlias() != null ? call.getAlias() :
                 new SqlIdentifier(deriveAlias(targetTable, 0), SqlParserPos.ZERO);
 
-        table.unwrap(IgniteTable.class).descriptor().selectForUpdateRowType((IgniteTypeFactory) typeFactory)
+        descriptor.selectForUpdateRowType((IgniteTypeFactory) typeFactory)
                 .getFieldNames().stream()
                 .map(name -> alias.plus(name, SqlParserPos.ZERO))
                 .forEach(selectList::add);
@@ -267,13 +291,11 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
     protected SqlSelect createSourceSelectForDelete(SqlDelete call) {
         final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
         final SqlIdentifier targetTable = (SqlIdentifier) call.getTargetTable();
-        final SqlValidatorTable table = getCatalogReader().getTable(targetTable.names);
 
-        if (table == null) {
-            throw newValidationError(targetTable, RESOURCE.objectNotFound(targetTable.toString()));
-        }
+        IgniteTable igniteTable = getTableForModification(targetTable);
+        TableDescriptor descriptor = igniteTable.descriptor();
 
-        table.unwrap(IgniteTable.class).descriptor().deleteRowType((IgniteTypeFactory) typeFactory)
+        descriptor.deleteRowType((IgniteTypeFactory) typeFactory)
                 .getFieldNames().stream()
                 .map(name -> new SqlIdentifier(name, SqlParserPos.ZERO))
                 .forEach(selectList::add);
@@ -551,22 +573,11 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
         }
     }
 
-    private SqlNodeList inferColumnList(SqlInsert call) {
-        final SqlValidatorTable table = table(validatedNamespace(call, unknownType));
+    private SqlNodeList inferColumnList(IgniteTable igniteTable) {
+        SqlNodeList columnList = new SqlNodeList(SqlParserPos.ZERO);
+        TableDescriptor descriptor = igniteTable.descriptor();
 
-        if (table == null) {
-            return null;
-        }
-
-        final TableDescriptor desc = table.unwrap(TableDescriptor.class);
-
-        if (desc == null) {
-            return null;
-        }
-
-        final SqlNodeList columnList = new SqlNodeList(SqlParserPos.ZERO);
-
-        for (RelDataTypeField field : desc.insertRowType(typeFactory()).getFieldList()) {
+        for (RelDataTypeField field : descriptor.insertRowType(typeFactory()).getFieldList()) {
             columnList.add(new SqlIdentifier(field.getName(), SqlParserPos.ZERO));
         }
 
@@ -579,18 +590,9 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
         }
 
         final SqlValidatorNamespace ns = validatedNamespace(call, unknownType);
-
         final SqlValidatorTable table = table(ns);
-
-        if (table == null) {
-            return;
-        }
-
-        final TableDescriptor desc = table.unwrap(TableDescriptor.class);
-
-        if (desc == null) {
-            return;
-        }
+        IgniteTable igniteTable = getIgniteTableForModification((SqlIdentifier) call.getTargetTable(), table);
+        TableDescriptor descriptor = igniteTable.descriptor();
 
         final RelDataType baseType = table.getRowType();
         final RelOptTable relOptTable = relOptTable(ns);
@@ -606,7 +608,7 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
                         RESOURCE.unknownTargetColumn(id.toString()));
             }
 
-            if (!desc.isUpdateAllowed(relOptTable, target.getIndex())) {
+            if (!descriptor.isUpdateAllowed(relOptTable, target.getIndex())) {
                 throw newValidationError(id,
                         IgniteResource.INSTANCE.cannotUpdateField(id.toString()));
             }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/PlannerPhase.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/PlannerPhase.java
index 7d4af086f4..adda00bccb 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/PlannerPhase.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/PlannerPhase.java
@@ -88,6 +88,7 @@ public enum PlannerPhase {
     HEP_FILTER_PUSH_DOWN(
             "Heuristic phase to push down filters",
             FilterScanMergeRule.TABLE_SCAN_SKIP_CORRELATED,
+            FilterScanMergeRule.SYSTEM_VIEW_SCAN_SKIP_CORRELATED,
 
             CoreRules.FILTER_MERGE,
             CoreRules.FILTER_AGGREGATE_TRANSPOSE,
@@ -106,6 +107,7 @@ public enum PlannerPhase {
     HEP_PROJECT_PUSH_DOWN(
             "Heuristic phase to push down and merge projects",
             ProjectScanMergeRule.TABLE_SCAN_SKIP_CORRELATED,
+            ProjectScanMergeRule.SYSTEM_VIEW_SCAN_SKIP_CORRELATED,
 
             CoreRules.JOIN_PUSH_EXPRESSIONS,
             CoreRules.PROJECT_MERGE,
@@ -195,10 +197,12 @@ public enum PlannerPhase {
             ExposeIndexRule.INSTANCE,
             ProjectScanMergeRule.TABLE_SCAN,
             ProjectScanMergeRule.INDEX_SCAN,
+            ProjectScanMergeRule.SYSTEM_VIEW_SCAN,
             FilterSpoolMergeToSortedIndexSpoolRule.INSTANCE,
             FilterSpoolMergeToHashIndexSpoolRule.INSTANCE,
             FilterScanMergeRule.TABLE_SCAN,
             FilterScanMergeRule.INDEX_SCAN,
+            FilterScanMergeRule.SYSTEM_VIEW_SCAN,
 
             LogicalOrToUnionRule.INSTANCE,
 
@@ -211,6 +215,7 @@ public enum PlannerPhase {
             ValuesConverterRule.INSTANCE,
             LogicalScanConverterRule.INDEX_SCAN,
             LogicalScanConverterRule.TABLE_SCAN,
+            LogicalScanConverterRule.SYSTEM_VIEW_SCAN,
             HashAggregateConverterRule.COLOCATED,
             HashAggregateConverterRule.MAP_REDUCE,
             SortAggregateConverterRule.COLOCATED,
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/IgniteRelVisitor.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/IgniteRelVisitor.java
index 0fb0367980..3bf9f9fafe 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/IgniteRelVisitor.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/IgniteRelVisitor.java
@@ -74,6 +74,11 @@ public interface IgniteRelVisitor<T> {
      */
     T visit(IgniteTableScan rel);
 
+    /**
+     * See {@link IgniteRelVisitor#visit(IgniteRel)}.
+     */
+    T visit(IgniteSystemViewScan rel);
+
     /**
      * See {@link IgniteRelVisitor#visit(IgniteRel)}.
      */
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/IgniteSystemViewScan.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/IgniteSystemViewScan.java
new file mode 100644
index 0000000000..47b3e60073
--- /dev/null
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/IgniteSystemViewScan.java
@@ -0,0 +1,130 @@
+/*
+ * 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.rel;
+
+import static org.apache.ignite.internal.sql.engine.trait.TraitUtils.changeTraits;
+
+import java.util.List;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelInput;
+import org.apache.calcite.rel.RelWriter;
+import org.apache.calcite.rel.hint.RelHint;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.util.ImmutableBitSet;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Relational operator that returns the contents of a system view.
+ */
+public class IgniteSystemViewScan extends ProjectableFilterableTableScan implements SourceAwareIgniteRel {
+
+    private final long sourceId;
+
+    /**
+     * Constructor.
+     *
+     * @param cluster Cluster this relational expression belongs to.
+     * @param traitSet Traits of this relational expression.
+     * @param hints Optimizer hints.
+     * @param projections Projection list.
+     * @param condition Filter condition.
+     * @param table Target system view to read data from.
+     * @param reqColumns Participating columns.
+     */
+    public IgniteSystemViewScan(RelOptCluster cluster, RelTraitSet traitSet,
+            List<RelHint> hints,
+            RelOptTable table,
+            @Nullable List<RexNode> projections,
+            @Nullable RexNode condition,
+            @Nullable ImmutableBitSet reqColumns) {
+
+        this(-1, cluster, traitSet, hints, table, projections, condition, reqColumns);
+    }
+
+    /**
+     * Constructor used for deserialization.
+     *
+     * @param input Serialized representation.
+     */
+    public IgniteSystemViewScan(RelInput input) {
+        super(changeTraits(input, IgniteConvention.INSTANCE));
+
+        Object srcIdObj = input.get("sourceId");
+        if (srcIdObj != null) {
+            sourceId = ((Number) srcIdObj).longValue();
+        } else {
+            sourceId = -1;
+        }
+    }
+
+    private IgniteSystemViewScan(long sourceId,
+            RelOptCluster cluster,
+            RelTraitSet traitSet,
+            List<RelHint> hints,
+            RelOptTable table,
+            @Nullable List<RexNode> proj,
+            @Nullable RexNode cond,
+            @Nullable ImmutableBitSet reqColumns) {
+
+        super(cluster, traitSet, hints, table, proj, cond, reqColumns);
+
+        this.sourceId = sourceId;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public <T> T accept(IgniteRelVisitor<T> visitor) {
+        return visitor.visit(this);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public long sourceId() {
+        return sourceId;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public IgniteRel clone(long sourceId) {
+        return new IgniteSystemViewScan(sourceId, getCluster(), getTraitSet(), getHints(), getTable(),
+                projects, condition, requiredColumns);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public IgniteRel clone(RelOptCluster cluster, List<IgniteRel> inputs) {
+        return new IgniteSystemViewScan(sourceId, cluster, getTraitSet(), getHints(), getTable(),
+                projects, condition, requiredColumns);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public IgniteSystemViewScan withHints(List<RelHint> hintList) {
+        return new IgniteSystemViewScan(sourceId, getCluster(), getTraitSet(), hintList, getTable(),
+                projects, condition, requiredColumns);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected RelWriter explainTerms0(RelWriter pw) {
+        return super.explainTerms0(pw)
+                .itemIf("sourceId", sourceId, sourceId != -1);
+    }
+}
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/ProjectableFilterableTableScan.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/ProjectableFilterableTableScan.java
index a9d71db288..75c604d4fd 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/ProjectableFilterableTableScan.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/ProjectableFilterableTableScan.java
@@ -45,6 +45,7 @@ import org.apache.calcite.util.ControlFlowException;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.mapping.Mappings;
 import org.apache.ignite.internal.sql.engine.metadata.cost.IgniteCost;
+import org.apache.ignite.internal.sql.engine.schema.IgniteDataSource;
 import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
 import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
 import org.apache.ignite.internal.sql.engine.util.Commons;
@@ -127,7 +128,7 @@ public abstract class ProjectableFilterableTableScan extends TableScan {
     public RelWriter explainTerms(RelWriter pw) {
         return explainTerms0(pw
                 .item("table", table.getQualifiedName())
-                .itemIf("tableId", Integer.toString(table.unwrap(IgniteTable.class).id()),
+                .itemIf("tableId", Integer.toString(table.unwrap(IgniteDataSource.class).id()),
                 pw.getDetailLevel() == ALL_ATTRIBUTES));
     }
 
@@ -175,7 +176,7 @@ public abstract class ProjectableFilterableTableScan extends TableScan {
         if (projects != null) {
             return RexUtil.createStructType(Commons.typeFactory(getCluster()), projects);
         } else {
-            return table.unwrap(IgniteTable.class).getRowType(Commons.typeFactory(getCluster()), requiredColumns);
+            return table.unwrap(IgniteDataSource.class).getRowType(Commons.typeFactory(getCluster()), requiredColumns);
         }
     }
 
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 5b6efda630..ca2b741e3f 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
@@ -36,8 +36,7 @@ import org.apache.ignite.internal.sql.engine.util.RexUtils;
 import org.jetbrains.annotations.Nullable;
 
 /**
- * IgniteLogicalIndexScan.
- * TODO Documentation https://issues.apache.org/jira/browse/IGNITE-15859
+ * Logical relational expression for reading data from an index.
  */
 public class IgniteLogicalIndexScan extends AbstractIndexScan {
     /** Creates a IgniteLogicalIndexScan. */
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalTableScan.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalSystemViewScan.java
similarity index 54%
copy from modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalTableScan.java
copy to modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalSystemViewScan.java
index 32d76a1264..52f633a1cc 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalTableScan.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalSystemViewScan.java
@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 
+
 package org.apache.ignite.internal.sql.engine.rel.logical;
 
 import java.util.List;
@@ -28,35 +29,28 @@ import org.apache.ignite.internal.sql.engine.rel.ProjectableFilterableTableScan;
 import org.jetbrains.annotations.Nullable;
 
 /**
- * IgniteLogicalTableScan.
- * TODO Documentation https://issues.apache.org/jira/browse/IGNITE-15859
+ * Logical relational expression for reading data from a system view.
  */
-public class IgniteLogicalTableScan extends ProjectableFilterableTableScan {
-    /** Creates a IgniteTableScan. */
-    public static IgniteLogicalTableScan create(
-            RelOptCluster cluster,
-            RelTraitSet traits,
-            List<RelHint> hints,
-            RelOptTable tbl,
-            @Nullable List<RexNode> proj,
-            @Nullable RexNode cond,
-            @Nullable ImmutableBitSet requiredColumns
-    ) {
-        return new IgniteLogicalTableScan(cluster, traits, hints, tbl, proj, cond, requiredColumns);
-    }
+public class IgniteLogicalSystemViewScan extends ProjectableFilterableTableScan {
 
     /**
-     * Creates a TableScan.
+     * Creates asSystem view scan.
      *
-     * @param cluster         Cluster that this relational expression belongs to.
-     * @param traits          Traits of this relational expression.
-     * @param hints           Table hints.
-     * @param tbl             Table definition.
-     * @param proj            Projects.
-     * @param cond            Filters.
-     * @param requiredColumns Participating columns.
+     * @param cluster Cluster that this relational expression belongs to.
+     * @param hints Table hints.
+     * @param table Table definition.
+     * @param projections Projection list.
+     * @param condition Filter condition.
+     * @param reqColumns Participating columns.
      */
-    private IgniteLogicalTableScan(
+    private IgniteLogicalSystemViewScan(RelOptCluster cluster, RelTraitSet traitSet,
+            List<RelHint> hints, RelOptTable table,
+            @Nullable List<RexNode> projections, @Nullable RexNode condition, @Nullable ImmutableBitSet reqColumns) {
+        super(cluster, traitSet, hints, table, projections, condition, reqColumns);
+    }
+
+    /** Creates an instance of a logical system view scan operator. */
+    public static IgniteLogicalSystemViewScan create(
             RelOptCluster cluster,
             RelTraitSet traits,
             List<RelHint> hints,
@@ -65,12 +59,13 @@ public class IgniteLogicalTableScan extends ProjectableFilterableTableScan {
             @Nullable RexNode cond,
             @Nullable ImmutableBitSet requiredColumns
     ) {
-        super(cluster, traits, hints, tbl, proj, cond, requiredColumns);
+        return new IgniteLogicalSystemViewScan(cluster, traits, hints, tbl, proj, cond, requiredColumns);
     }
 
     /** {@inheritDoc} */
     @Override
-    public IgniteLogicalTableScan withHints(List<RelHint> hintList) {
-        return new IgniteLogicalTableScan(getCluster(), getTraitSet(), hintList, getTable(), projects, condition, requiredColumns);
+    public IgniteLogicalSystemViewScan withHints(List<RelHint> hintList) {
+        return new IgniteLogicalSystemViewScan(getCluster(), getTraitSet(), hintList, getTable(),
+                projects, condition, requiredColumns);
     }
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalTableScan.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalTableScan.java
index 32d76a1264..6a77fd6481 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalTableScan.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rel/logical/IgniteLogicalTableScan.java
@@ -28,8 +28,7 @@ import org.apache.ignite.internal.sql.engine.rel.ProjectableFilterableTableScan;
 import org.jetbrains.annotations.Nullable;
 
 /**
- * IgniteLogicalTableScan.
- * TODO Documentation https://issues.apache.org/jira/browse/IGNITE-15859
+ * Logical relational expression for reading data from a table.
  */
 public class IgniteLogicalTableScan extends ProjectableFilterableTableScan {
     /** Creates a IgniteTableScan. */
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 e5bd22f03f..3412b5bab0 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
@@ -35,22 +35,30 @@ import org.apache.calcite.util.mapping.Mapping;
 import org.apache.calcite.util.mapping.Mappings;
 import org.apache.ignite.internal.sql.engine.rel.IgniteConvention;
 import org.apache.ignite.internal.sql.engine.rel.IgniteIndexScan;
+import org.apache.ignite.internal.sql.engine.rel.IgniteSystemViewScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan;
 import org.apache.ignite.internal.sql.engine.rel.ProjectableFilterableTableScan;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
+import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalSystemViewScan;
 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.IgniteSystemView;
 import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
 
 /**
- * LogicalScanConverterRule.
- * TODO Documentation https://issues.apache.org/jira/browse/IGNITE-15859
+ * Converts a logical scan operator into its implementation.
+ *
+ * <ul>
+ *     <li>{@link IgniteLogicalTableScan Table scan} to {@link IgniteTableScan}.</li>
+ *     <li>{@link IgniteLogicalIndexScan Index scan} to {@link IgniteIndexScan}.</li>
+ *     <li>{@link IgniteLogicalSystemViewScan System view scan} to {@link IgniteSystemViewScan}.</li>
+ * </ul>
  */
 public abstract class LogicalScanConverterRule<T extends ProjectableFilterableTableScan> extends AbstractIgniteConverterRule<T> {
     /** Instance. */
     public static final LogicalScanConverterRule<IgniteLogicalIndexScan> INDEX_SCAN =
-            new LogicalScanConverterRule<IgniteLogicalIndexScan>(IgniteLogicalIndexScan.class, "LogicalIndexScanConverterRule") {
+            new LogicalScanConverterRule<>(IgniteLogicalIndexScan.class, "LogicalIndexScanConverterRule") {
 
                 /** {@inheritDoc} */
                 @Override
@@ -99,7 +107,7 @@ public abstract class LogicalScanConverterRule<T extends ProjectableFilterableTa
 
     /** Instance. */
     public static final LogicalScanConverterRule<IgniteLogicalTableScan> TABLE_SCAN =
-            new LogicalScanConverterRule<IgniteLogicalTableScan>(IgniteLogicalTableScan.class, "LogicalTableScanConverterRule") {
+            new LogicalScanConverterRule<>(IgniteLogicalTableScan.class, "LogicalTableScanConverterRule") {
                 /** {@inheritDoc} */
                 @Override protected PhysicalNode convert(
                         RelOptPlanner planner,
@@ -128,6 +136,36 @@ public abstract class LogicalScanConverterRule<T extends ProjectableFilterableTa
                 }
             };
 
+    /** Instance. */
+    public static final LogicalScanConverterRule<IgniteLogicalSystemViewScan> SYSTEM_VIEW_SCAN =
+            new LogicalScanConverterRule<>(IgniteLogicalSystemViewScan.class, "LogicalSystemViewScanConverterRule") {
+                /** {@inheritDoc} */
+                @Override protected PhysicalNode convert(
+                        RelOptPlanner planner,
+                        RelMetadataQuery mq,
+                        IgniteLogicalSystemViewScan rel
+                ) {
+                    RelOptCluster cluster = rel.getCluster();
+                    IgniteSystemView systemView = rel.getTable().unwrap(IgniteSystemView.class);
+
+                    RelDistribution distribution = systemView.distribution();
+                    if (rel.requiredColumns() != null) {
+                        Mappings.TargetMapping mapping = createMapping(
+                                rel.projects(),
+                                rel.requiredColumns(),
+                                systemView.getRowType(cluster.getTypeFactory()).getFieldCount()
+                        );
+
+                        distribution = distribution.apply(mapping);
+                    }
+
+                    RelTraitSet traits = cluster.traitSetOf(IgniteConvention.INSTANCE)
+                            .replace(distribution);
+
+                    return new IgniteSystemViewScan(rel.getCluster(), traits,  rel.getHints(), rel.getTable(),
+                            rel.projects(), rel.condition(), rel.requiredColumns());
+                }
+            };
 
     private LogicalScanConverterRule(Class<T> clazz, String descPrefix) {
         super(clazz, descPrefix);
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/FilterScanMergeRule.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/FilterScanMergeRule.java
index 8806029894..fde93bf5c2 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/FilterScanMergeRule.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/FilterScanMergeRule.java
@@ -34,6 +34,7 @@ import org.apache.calcite.rex.RexSimplify;
 import org.apache.calcite.rex.RexUtil;
 import org.apache.ignite.internal.sql.engine.rel.ProjectableFilterableTableScan;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
+import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalSystemViewScan;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan;
 import org.apache.ignite.internal.sql.engine.util.RexUtils;
 import org.immutables.value.Value;
@@ -51,6 +52,10 @@ public abstract class FilterScanMergeRule<T extends ProjectableFilterableTableSc
 
     public static final RelOptRule TABLE_SCAN_SKIP_CORRELATED = Config.TABLE_SCAN_SKIP_CORRELATED.toRule();
 
+    public static final RelOptRule SYSTEM_VIEW_SCAN = Config.SYSTEM_VIEW_SCAN.toRule();
+
+    public static final RelOptRule SYSTEM_VIEW_SCAN_SKIP_CORRELATED = Config.SYSTEM_VIEW_SCAN_SKIP_CORRELATED.toRule();
+
     /**
      * Constructor.
      *
@@ -140,6 +145,24 @@ public abstract class FilterScanMergeRule<T extends ProjectableFilterableTableSc
         }
     }
 
+    private static class FilterSystemViewScanMergeRule extends FilterScanMergeRule<IgniteLogicalSystemViewScan> {
+        private FilterSystemViewScanMergeRule(FilterScanMergeRule.Config cfg) {
+            super(cfg);
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        protected IgniteLogicalSystemViewScan createNode(
+                RelOptCluster cluster,
+                IgniteLogicalSystemViewScan scan,
+                RelTraitSet traits,
+                RexNode cond
+        ) {
+            return IgniteLogicalSystemViewScan.create(cluster, traits, scan.getHints(), scan.getTable(), scan.projects(),
+                    cond, scan.requiredColumns());
+        }
+    }
+
     /**
      * Rule's configuration.
      */
@@ -160,6 +183,14 @@ public abstract class FilterScanMergeRule<T extends ProjectableFilterableTableSc
                 .withRuleFactory(FilterIndexScanMergeRule::new)
                 .withScanRuleConfig(IgniteLogicalIndexScan.class, "FilterIndexScanMergeRule", false);
 
+        Config SYSTEM_VIEW_SCAN = DEFAULT
+                .withRuleFactory(FilterSystemViewScanMergeRule::new)
+                .withScanRuleConfig(IgniteLogicalSystemViewScan.class, "FilterSystemViewScanMergeRule", false);
+
+        Config SYSTEM_VIEW_SCAN_SKIP_CORRELATED = DEFAULT
+                .withRuleFactory(FilterSystemViewScanMergeRule::new)
+                .withScanRuleConfig(IgniteLogicalSystemViewScan.class, "FilterSystemViewScanMergeSkipCorrelatedRule", true);
+
         /**
          * Create configuration for specified scan.
          */
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/ProjectScanMergeRule.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/ProjectScanMergeRule.java
index 607528825f..0c9230c76d 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/ProjectScanMergeRule.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rule/logical/ProjectScanMergeRule.java
@@ -32,16 +32,17 @@ import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.mapping.Mappings;
 import org.apache.ignite.internal.sql.engine.rel.ProjectableFilterableTableScan;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan;
+import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalSystemViewScan;
 import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan;
-import org.apache.ignite.internal.sql.engine.schema.IgniteTable;
+import org.apache.ignite.internal.sql.engine.schema.IgniteDataSource;
 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;
 import org.immutables.value.Value;
 
 /**
- * ProjectScanMergeRule.
- * TODO Documentation https://issues.apache.org/jira/browse/IGNITE-15859
+ * Rule that pushes filters and projections into a scan operation. This rule also prunes unused columns from a scan operator.
+ * This rule operates on operators that support such options (see {@link ProjectableFilterableTableScan} and its subclasses).
  */
 @Value.Enclosing
 public abstract class ProjectScanMergeRule<T extends ProjectableFilterableTableScan>
@@ -53,6 +54,9 @@ public abstract class ProjectScanMergeRule<T extends ProjectableFilterableTableS
 
     public static final RelOptRule TABLE_SCAN_SKIP_CORRELATED = Config.TABLE_SCAN_SKIP_CORRELATED.toRule();
 
+    public static final RelOptRule SYSTEM_VIEW_SCAN = Config.SYSTEM_VIEW_SCAN.toRule();
+
+    public static final RelOptRule SYSTEM_VIEW_SCAN_SKIP_CORRELATED = Config.SYSTEM_VIEW_SCAN_SKIP_CORRELATED.toRule();
 
     protected abstract T createNode(
             RelOptCluster cluster,
@@ -86,7 +90,7 @@ public abstract class ProjectScanMergeRule<T extends ProjectableFilterableTableS
         // Set default traits, real traits will be calculated for physical node.
         RelTraitSet traits = cluster.traitSet();
 
-        IgniteTable tbl = scan.getTable().unwrap(IgniteTable.class);
+        IgniteDataSource tbl = scan.getTable().unwrap(IgniteDataSource.class);
         IgniteTypeFactory typeFactory = Commons.typeFactory(cluster);
 
         if (requiredColumns == null) {
@@ -209,6 +213,37 @@ public abstract class ProjectScanMergeRule<T extends ProjectableFilterableTableS
         }
     }
 
+    private static class ProjectSystemViewScanMergeRule extends ProjectScanMergeRule<IgniteLogicalSystemViewScan> {
+        /**
+         * Constructor.
+         *
+         * @param config Project scan merge rule config,
+         */
+        private ProjectSystemViewScanMergeRule(ProjectScanMergeRule.Config config) {
+            super(config);
+        }
+
+        /** {@inheritDoc} */
+        @Override protected IgniteLogicalSystemViewScan createNode(
+                RelOptCluster cluster,
+                IgniteLogicalSystemViewScan scan,
+                RelTraitSet traits,
+                List<RexNode> projections,
+                RexNode cond,
+                ImmutableBitSet requiredColumns
+        ) {
+            return IgniteLogicalSystemViewScan.create(
+                    cluster,
+                    traits,
+                    scan.getHints(),
+                    scan.getTable(),
+                    projections,
+                    cond,
+                    requiredColumns
+            );
+        }
+    }
+
     /**
      * Rule's configuration.
      */
@@ -229,6 +264,15 @@ public abstract class ProjectScanMergeRule<T extends ProjectableFilterableTableS
                 .withRuleFactory(ProjectIndexScanMergeRule::new)
                 .withScanRuleConfig(IgniteLogicalIndexScan.class, "ProjectIndexScanMergeRule", false);
 
+        Config SYSTEM_VIEW_SCAN = DEFAULT
+                .withRuleFactory(ProjectSystemViewScanMergeRule::new)
+                .withScanRuleConfig(IgniteLogicalSystemViewScan.class, "ProjectSystemViewScanMergeRule", false);
+
+        Config SYSTEM_VIEW_SCAN_SKIP_CORRELATED = DEFAULT
+                .withRuleFactory(ProjectSystemViewScanMergeRule::new)
+                .withScanRuleConfig(IgniteLogicalSystemViewScan.class, "ProjectSystemViewScanMergeSkipCorrelatedRule", true);
+
+
         /**
          * Create rule's configuration.
          */
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/AbstractIgniteDataSource.java
similarity index 71%
copy from modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteTableImpl.java
copy to modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/AbstractIgniteDataSource.java
index 1bd7d1e181..6e2c14aa2f 100644
--- 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/AbstractIgniteDataSource.java
@@ -18,7 +18,6 @@
 package org.apache.ignite.internal.sql.engine.schema;
 
 import java.util.List;
-import java.util.Map;
 import org.apache.calcite.config.CalciteConnectionConfig;
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptTable;
@@ -27,22 +26,21 @@ import org.apache.calcite.rel.core.TableScan;
 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.Schema;
 import org.apache.calcite.schema.Statistic;
 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.IgniteLogicalTableScan;
 import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
 import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
 import org.jetbrains.annotations.Nullable;
 
+
 /**
- * Table implementation for sql engine.
+ * Base implementation of {@link IgniteDataSource}.
  */
-public final class IgniteTableImpl extends AbstractTable implements IgniteTable {
+public abstract class AbstractIgniteDataSource extends AbstractTable implements IgniteDataSource {
 
     private final String name;
 
@@ -52,20 +50,17 @@ public final class IgniteTableImpl extends AbstractTable implements IgniteTable
 
     private final int version;
 
-    private final IgniteStatistic statistic;
-
-    private final Map<String, IgniteIndex> indexMap;
+    private final Statistic statistic;
 
     /** Constructor. */
-    public IgniteTableImpl(String name, int tableId,  int version, TableDescriptor desc,
-            IgniteStatistic statistic, Map<String, IgniteIndex> indexMap) {
+    public AbstractIgniteDataSource(String name, int id,  int version, TableDescriptor desc,
+            Statistic statistic) {
 
-        this.id = tableId;
+        this.id = id;
         this.name = name;
         this.desc = desc;
         this.version = version;
         this.statistic = statistic;
-        this.indexMap = indexMap;
     }
 
     /** {@inheritDoc} */
@@ -106,31 +101,15 @@ public final class IgniteTableImpl extends AbstractTable implements IgniteTable
 
     /** {@inheritDoc} */
     @Override
-    public TableScan toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable) {
-        return toRel(context.getCluster(), relOptTable, context.getTableHints());
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteLogicalTableScan toRel(RelOptCluster cluster, RelOptTable relOptTbl, List<RelHint> hints) {
-        return toRel(cluster, relOptTbl, hints, null, null, null);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteLogicalTableScan toRel(
-            RelOptCluster cluster,
-            RelOptTable relOptTbl,
-            List<RelHint> hints,
-            @Nullable List<RexNode> proj,
-            @Nullable RexNode cond,
-            @Nullable ImmutableBitSet requiredColumns
-    ) {
+    public final TableScan toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable) {
+        RelOptCluster cluster = context.getCluster();
         RelTraitSet traitSet = cluster.traitSetOf(distribution());
-
-        return IgniteLogicalTableScan.create(cluster, traitSet, hints, relOptTbl, proj, cond, requiredColumns);
+        return toRel(cluster, traitSet, relOptTable, context.getTableHints());
     }
 
+    /** Converts this data source to a scan expression. */
+    protected abstract TableScan toRel(RelOptCluster cluster, RelTraitSet traitSet, RelOptTable relOptTbl, List<RelHint> hints);
+
     /** {@inheritDoc} */
     @Override
     public IgniteDistribution distribution() {
@@ -169,13 +148,6 @@ public final class IgniteTableImpl extends AbstractTable implements IgniteTable
         if (cls.isInstance(desc)) {
             return cls.cast(desc);
         }
-
         return super.unwrap(cls);
     }
-
-    /** {@inheritDoc} */
-    @Override
-    public Map<String, IgniteIndex> indexes() {
-        return indexMap;
-    }
 }
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 d14cf11afa..c8dcfb56da 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
@@ -44,6 +44,8 @@ import org.apache.ignite.internal.catalog.descriptors.CatalogHashIndexDescriptor
 import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogSchemaDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogSortedIndexDescriptor;
+import org.apache.ignite.internal.catalog.descriptors.CatalogSystemViewDescriptor;
+import org.apache.ignite.internal.catalog.descriptors.CatalogSystemViewDescriptor.SystemViewType;
 import org.apache.ignite.internal.catalog.descriptors.CatalogTableColumnDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor;
 import org.apache.ignite.internal.schema.DefaultValueGenerator;
@@ -84,9 +86,9 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
     /** {@inheritDoc} */
     @Override
     public SchemaPlus schema(@Nullable String name, long timestamp) {
-        int schemaVersion = catalogManager.activeCatalogVersion(timestamp);
+        int catalogVersion = catalogManager.activeCatalogVersion(timestamp);
 
-        return schema(name, schemaVersion);
+        return schema(name, catalogVersion);
     }
 
     /** {@inheritDoc} */
@@ -100,12 +102,12 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
         String schemaName = schemaDescriptor.name();
 
         int numTables = schemaDescriptor.tables().length;
-        List<IgniteTable> schemaTables = new ArrayList<>(numTables);
+        List<IgniteDataSource> schemaDataSources = new ArrayList<>(numTables);
         Int2ObjectMap<TableDescriptor> tableDescriptorMap = new Int2ObjectOpenHashMap<>(numTables);
 
         // Assemble sql-engine.TableDescriptors as they are required by indexes.
         for (CatalogTableDescriptor tableDescriptor : schemaDescriptor.tables()) {
-            TableDescriptor descriptor = createTableDescriptor(tableDescriptor);
+            TableDescriptor descriptor = createTableDescriptorForTable(tableDescriptor);
             tableDescriptorMap.put(tableDescriptor.id(), descriptor);
         }
 
@@ -140,12 +142,22 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
 
             IgniteTable schemaTable = new IgniteTableImpl(tableName, tableId, version, descriptor, statistic, tableIndexMap);
 
-            schemaTables.add(schemaTable);
+            schemaDataSources.add(schemaTable);
+        }
+
+        for (CatalogSystemViewDescriptor systemViewDescriptor : schemaDescriptor.systemViews()) {
+            int viewId = systemViewDescriptor.id();
+            String viewName = systemViewDescriptor.name();
+            TableDescriptor descriptor = createTableDescriptorForSystemView(systemViewDescriptor);
+
+            IgniteSystemView schemaTable = new IgniteSystemViewImpl(viewName, viewId, version, descriptor);
+
+            schemaDataSources.add(schemaTable);
         }
 
         // create root schema
         SchemaPlus rootSchema = Frameworks.createRootSchema(false);
-        IgniteSchema igniteSchema = new IgniteSchema(schemaName, version, schemaTables);
+        IgniteSchema igniteSchema = new IgniteSchema(schemaName, version, schemaDataSources);
         return rootSchema.add(schemaName, igniteSchema);
     }
 
@@ -163,60 +175,15 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
         return new IgniteIndex(indexDescriptor.id(), indexDescriptor.name(), type, tableDescriptor.distribution(), outputCollation);
     }
 
-    private static TableDescriptor createTableDescriptor(CatalogTableDescriptor descriptor) {
+    private static TableDescriptor createTableDescriptorForTable(CatalogTableDescriptor descriptor) {
         List<ColumnDescriptor> colDescriptors = new ArrayList<>();
-        List<Integer> colocationColumns = new ArrayList<>();
+        List<Integer> colocationColumns = new ArrayList<>(descriptor.colocationColumns().size());
 
         List<CatalogTableColumnDescriptor> columns = descriptor.columns();
         for (int i = 0; i < columns.size(); i++) {
             CatalogTableColumnDescriptor col = columns.get(i);
-            boolean nullable = col.nullable();
             boolean key = descriptor.isPrimaryKeyColumn(col.name());
-
-            DefaultValue defaultVal = col.defaultValue();
-            DefaultValueStrategy defaultValueStrategy;
-            Supplier<Object> defaultValueSupplier;
-
-            if (defaultVal != null) {
-                switch (defaultVal.type()) {
-                    case CONSTANT:
-                        ConstantValue constantValue = (ConstantValue) defaultVal;
-                        if (constantValue.value() == null) {
-                            defaultValueStrategy = DefaultValueStrategy.DEFAULT_NULL;
-                            defaultValueSupplier = () -> null;
-                        } else {
-                            defaultValueStrategy = DefaultValueStrategy.DEFAULT_CONSTANT;
-                            defaultValueSupplier = constantValue::value;
-                        }
-                        break;
-                    case FUNCTION_CALL:
-                        FunctionCall functionCall = (FunctionCall) defaultVal;
-                        String functionName = functionCall.functionName().toUpperCase(Locale.US);
-                        DefaultValueGenerator defaultValueGenerator = DefaultValueGenerator.valueOf(functionName);
-                        defaultValueStrategy = DefaultValueStrategy.DEFAULT_COMPUTED;
-                        defaultValueSupplier = defaultValueGenerator::next;
-                        break;
-                    default:
-                        throw new IllegalArgumentException("Unexpected default value: ");
-                }
-            } else {
-                defaultValueStrategy = null;
-                defaultValueSupplier = null;
-            }
-
-
-            CatalogColumnDescriptor columnDescriptor = new CatalogColumnDescriptor(
-                    col.name(),
-                    key,
-                    nullable,
-                    i,
-                    col.type(),
-                    col.precision(),
-                    col.scale(),
-                    col.length(),
-                    defaultValueStrategy,
-                    defaultValueSupplier
-            );
+            CatalogColumnDescriptor columnDescriptor = createColumnDescriptor(col, key, i);
 
             if (descriptor.isColocationColumn(col.name())) {
                 colocationColumns.add(i);
@@ -232,6 +199,85 @@ public class CatalogSqlSchemaManager implements SqlSchemaManager {
         return new TableDescriptorImpl(colDescriptors, distribution);
     }
 
+    private static TableDescriptor createTableDescriptorForSystemView(CatalogSystemViewDescriptor descriptor) {
+        List<ColumnDescriptor> colDescriptors = new ArrayList<>();
+
+        List<CatalogTableColumnDescriptor> columns = descriptor.columns();
+        for (int i = 0; i < columns.size(); i++) {
+            CatalogTableColumnDescriptor col = columns.get(i);
+            CatalogColumnDescriptor columnDescriptor = createColumnDescriptor(col, false, i);
+
+            colDescriptors.add(columnDescriptor);
+        }
+
+        IgniteDistribution distribution;
+        SystemViewType systemViewType = descriptor.systemViewType();
+
+        switch (systemViewType) {
+            case LOCAL:
+                // node name is always the first column.
+                distribution = IgniteDistributions.identity(0);
+                break;
+            case GLOBAL:
+                distribution = IgniteDistributions.single();
+                break;
+            default:
+                throw new IllegalArgumentException("Unexpected system view type: " + systemViewType);
+        }
+
+
+        return new TableDescriptorImpl(colDescriptors, distribution);
+    }
+
+    private static CatalogColumnDescriptor createColumnDescriptor(CatalogTableColumnDescriptor col, boolean key, int i) {
+        boolean nullable = col.nullable();
+
+        DefaultValue defaultVal = col.defaultValue();
+        DefaultValueStrategy defaultValueStrategy;
+        Supplier<Object> defaultValueSupplier;
+
+        if (defaultVal != null) {
+            switch (defaultVal.type()) {
+                case CONSTANT:
+                    ConstantValue constantValue = (ConstantValue) defaultVal;
+                    if (constantValue.value() == null) {
+                        defaultValueStrategy = DefaultValueStrategy.DEFAULT_NULL;
+                        defaultValueSupplier = () -> null;
+                    } else {
+                        defaultValueStrategy = DefaultValueStrategy.DEFAULT_CONSTANT;
+                        defaultValueSupplier = constantValue::value;
+                    }
+                    break;
+                case FUNCTION_CALL:
+                    FunctionCall functionCall = (FunctionCall) defaultVal;
+                    String functionName = functionCall.functionName().toUpperCase(Locale.US);
+                    DefaultValueGenerator defaultValueGenerator = DefaultValueGenerator.valueOf(functionName);
+                    defaultValueStrategy = DefaultValueStrategy.DEFAULT_COMPUTED;
+                    defaultValueSupplier = defaultValueGenerator::next;
+                    break;
+                default:
+                    throw new IllegalArgumentException("Unexpected default value: ");
+            }
+        } else {
+            defaultValueStrategy = null;
+            defaultValueSupplier = null;
+        }
+
+        CatalogColumnDescriptor columnDescriptor = new CatalogColumnDescriptor(
+                col.name(),
+                key,
+                nullable,
+                i,
+                col.type(),
+                col.precision(),
+                col.scale(),
+                col.length(),
+                defaultValueStrategy,
+                defaultValueSupplier
+        );
+        return columnDescriptor;
+    }
+
     private static CacheKey cacheKey(int schemaVersion, String schemaName) {
         return new CacheKey(schemaVersion, schemaName);
     }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteDataSource.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteDataSource.java
new file mode 100644
index 0000000000..642155788a
--- /dev/null
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteDataSource.java
@@ -0,0 +1,81 @@
+/*
+ * 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 org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.schema.TranslatableTable;
+import org.apache.calcite.schema.Wrapper;
+import org.apache.calcite.util.ImmutableBitSet;
+import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
+
+/**
+ * Base interface for data sources such as tables and views.
+ */
+public interface IgniteDataSource extends TranslatableTable, Wrapper {
+
+    /**
+     * Returns an id of the table.
+     *
+     * @return And id of the table.
+     */
+    int id();
+
+    /**
+     * Returns the version of the table's schema.
+     *
+     * @return the version of the table's schema.
+     */
+    int version();
+
+    /**
+     * Gets a name of the table.
+     *
+     * @return Table name.
+     */
+    String name();
+
+    /**
+     * Returns a descriptor of the table.
+     *
+     * @return A descriptor of the table.
+     */
+    TableDescriptor descriptor();
+
+    /** {@inheritDoc} */
+    @Override
+    default RelDataType getRowType(RelDataTypeFactory typeFactory) {
+        return getRowType(typeFactory, null);
+    }
+
+    /**
+     * Returns new type according {@code requiredColumns} param.
+     *
+     * @param typeFactory     Factory.
+     * @param requiredColumns Used columns enumeration.
+     */
+    RelDataType getRowType(RelDataTypeFactory typeFactory, ImmutableBitSet requiredColumns);
+
+    /**
+     * Returns distribution of this data source.
+     *
+     * @return Table distribution.
+     */
+    IgniteDistribution distribution();
+}
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 0a6f554f37..8d61c31a37 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
@@ -36,15 +36,16 @@ public class IgniteSchema extends AbstractSchema {
 
     private final int version;
 
-    private final Map<String, IgniteTable> tableByName;
-    private final Int2ObjectMap<IgniteTable> tableById;
+    private final Map<String, IgniteDataSource> tableByName;
+
+    private final Int2ObjectMap<IgniteDataSource> tableById;
 
     /** Constructor. */
-    public IgniteSchema(String name, int version, Collection<IgniteTable> tables) {
+    public IgniteSchema(String name, int version, Collection<? extends IgniteDataSource> tables) {
         this.name = name;
         this.version = version;
-        this.tableByName = tables.stream().collect(Collectors.toMap(IgniteTable::name, Function.identity()));
-        this.tableById = tables.stream().collect(CollectionUtils.toIntMapCollector(IgniteTable::id, Function.identity()));
+        this.tableByName = tables.stream().collect(Collectors.toMap(IgniteDataSource::name, Function.identity()));
+        this.tableById = tables.stream().collect(CollectionUtils.toIntMapCollector(IgniteDataSource::id, Function.identity()));
     }
 
     /** Schema name. */
@@ -65,6 +66,9 @@ public class IgniteSchema extends AbstractSchema {
 
     /** Returns table by given id. */
     public IgniteTable getTable(int tableId) {
-        return tableById.get(tableId);
+        IgniteDataSource dataSource = tableById.get(tableId);
+        assert dataSource instanceof IgniteTable : "Expected table but got " + dataSource;
+
+        return (IgniteTable) dataSource;
     }
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSystemView.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSystemView.java
new file mode 100644
index 0000000000..0d2d41d49e
--- /dev/null
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSystemView.java
@@ -0,0 +1,25 @@
+/*
+ * 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;
+
+/**
+ * System view representation as object in SQL schema.
+ */
+public interface IgniteSystemView extends IgniteDataSource {
+
+}
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSystemViewImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSystemViewImpl.java
new file mode 100644
index 0000000000..191d465678
--- /dev/null
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/IgniteSystemViewImpl.java
@@ -0,0 +1,61 @@
+/*
+ * 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.List;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelDistribution;
+import org.apache.calcite.rel.core.TableScan;
+import org.apache.calcite.rel.hint.RelHint;
+import org.apache.calcite.schema.Statistic;
+import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalSystemViewScan;
+import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * System view.
+ */
+public class IgniteSystemViewImpl extends AbstractIgniteDataSource implements IgniteSystemView {
+
+    /** Constructor. */
+    public IgniteSystemViewImpl(String name, int id, int version, TableDescriptor desc) {
+        super(name, id, version, desc, new SystemViewStatistic(desc.distribution()));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected TableScan toRel(RelOptCluster cluster, RelTraitSet traitSet, RelOptTable relOptTbl, List<RelHint> hints) {
+        return IgniteLogicalSystemViewScan.create(cluster, traitSet, hints, relOptTbl, null, null, null);
+    }
+
+    private static final class SystemViewStatistic implements Statistic {
+
+        private final IgniteDistribution distribution;
+
+        private SystemViewStatistic(IgniteDistribution distribution) {
+            this.distribution = distribution;
+        }
+
+        @Override
+        public @Nullable RelDistribution getDistribution() {
+            return distribution;
+        }
+    }
+}
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 2df9980786..4a2efe0b10 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
@@ -17,150 +17,12 @@
 
 package org.apache.ignite.internal.sql.engine.schema;
 
-import java.util.List;
 import java.util.Map;
-import org.apache.calcite.config.CalciteConnectionConfig;
-import org.apache.calcite.plan.RelOptCluster;
-import org.apache.calcite.plan.RelOptTable;
-import org.apache.calcite.rel.RelCollation;
-import org.apache.calcite.rel.core.TableScan;
-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.Schema;
-import org.apache.calcite.schema.Statistic;
-import org.apache.calcite.schema.TranslatableTable;
-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.IgniteLogicalTableScan;
-import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * Table representation as object in SQL schema.
  */
-public interface IgniteTable extends TranslatableTable, Wrapper {
-    /**
-     * Returns an id of the table.
-     *
-     * @return And id of the table.
-     */
-    int id();
-
-    /**
-     * Returns the version of the table's schema.
-     *
-     * @return the version of the table's schema.
-     */
-    int version();
-
-    /**
-     * Gets a name of the table.
-     *
-     * @return Table name.
-     */
-    String name();
-
-    /**
-     * Returns a descriptor of the table.
-     *
-     * @return A descriptor of the table.
-     */
-    TableDescriptor descriptor();
-
-    /** {@inheritDoc} */
-    @Override
-    default RelDataType getRowType(RelDataTypeFactory typeFactory) {
-        return getRowType(typeFactory, null);
-    }
-
-    /**
-     * Returns new type according {@code requiredColumns} param.
-     *
-     * @param typeFactory     Factory.
-     * @param requiredColumns Used columns enumeration.
-     */
-    RelDataType getRowType(RelDataTypeFactory typeFactory, ImmutableBitSet requiredColumns);
-
-    /** {@inheritDoc} */
-    @Override
-    default TableScan toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable) {
-        return toRel(context.getCluster(), relOptTable, context.getTableHints());
-    }
-
-    /**
-     * Converts table into relational expression.
-     *
-     * @param cluster   Custer.
-     * @param relOptTbl Table.
-     * @param hints     Hints.
-     * @return Table relational expression.
-     */
-    default IgniteLogicalTableScan toRel(RelOptCluster cluster, RelOptTable relOptTbl, List<RelHint> hints) {
-        return toRel(cluster, relOptTbl, hints, null, null, null);
-    }
-
-    /**
-     * Converts table into table scan relational expression.
-     */
-    IgniteLogicalTableScan toRel(
-            RelOptCluster cluster,
-            RelOptTable relOptTbl,
-            List<RelHint> hints,
-            @Nullable List<RexNode> proj,
-            @Nullable RexNode cond,
-            @Nullable ImmutableBitSet requiredColumns
-    );
-
-    /**
-     * Returns table distribution.
-     *
-     * @return Table distribution.
-     */
-    IgniteDistribution distribution();
-
-    /** {@inheritDoc} */
-    @Override
-    default Schema.TableType getJdbcTableType() {
-        return Schema.TableType.TABLE;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    default boolean isRolledUp(String column) {
-        return false;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    default boolean rolledUpColumnValidInsideAgg(String column, SqlCall call,
-            @Nullable SqlNode parent,
-            @Nullable CalciteConnectionConfig config) {
-        return false;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    default Statistic getStatistic() {
-        return new Statistic() {
-            @Override
-            public List<RelCollation> getCollations() {
-                return List.of();
-            }
-        };
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    default <C> @Nullable C unwrap(Class<C> cls) {
-        if (cls.isInstance(this)) {
-            return cls.cast(this);
-        }
-        return null;
-    }
+public interface IgniteTable extends IgniteDataSource {
 
     /**
      * Returns all table indexes.
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
index 1bd7d1e181..32349b7e69 100644
--- 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
@@ -19,163 +19,38 @@ package org.apache.ignite.internal.sql.engine.schema;
 
 import java.util.List;
 import java.util.Map;
-import org.apache.calcite.config.CalciteConnectionConfig;
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptTable;
 import org.apache.calcite.plan.RelTraitSet;
 import org.apache.calcite.rel.core.TableScan;
 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.Schema;
 import org.apache.calcite.schema.Statistic;
-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.IgniteLogicalTableScan;
-import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
-import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * Table implementation for sql engine.
  */
-public final class IgniteTableImpl extends AbstractTable implements IgniteTable {
-
-    private final String name;
-
-    private final TableDescriptor desc;
-
-    private final int id;
-
-    private final int version;
-
-    private final IgniteStatistic statistic;
+public class IgniteTableImpl extends AbstractIgniteDataSource implements IgniteTable {
 
     private final Map<String, IgniteIndex> indexMap;
 
     /** Constructor. */
-    public IgniteTableImpl(String name, int tableId,  int version, TableDescriptor desc,
-            IgniteStatistic statistic, Map<String, IgniteIndex> indexMap) {
+    public IgniteTableImpl(String name, int id,  int version, TableDescriptor desc,
+            Statistic statistic, Map<String, IgniteIndex> indexMap) {
 
-        this.id = tableId;
-        this.name = name;
-        this.desc = desc;
-        this.version = version;
-        this.statistic = statistic;
+        super(name, id, version, desc, statistic);
         this.indexMap = indexMap;
     }
 
     /** {@inheritDoc} */
     @Override
-    public int id() {
-        return id;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public int version() {
-        return version;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public String name() {
-        return name;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public TableDescriptor descriptor() {
-        return desc;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public RelDataType getRowType(RelDataTypeFactory typeFactory) {
-        return getRowType(typeFactory, null);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public RelDataType getRowType(RelDataTypeFactory typeFactory, ImmutableBitSet requiredColumns) {
-        return desc.rowType((IgniteTypeFactory) typeFactory, requiredColumns);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public TableScan toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable) {
-        return toRel(context.getCluster(), relOptTable, context.getTableHints());
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteLogicalTableScan toRel(RelOptCluster cluster, RelOptTable relOptTbl, List<RelHint> hints) {
-        return toRel(cluster, relOptTbl, hints, null, null, null);
-    }
-
-    /** {@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 IgniteDistribution distribution() {
-        return desc.distribution();
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public Schema.TableType getJdbcTableType() {
-        return Schema.TableType.TABLE;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public boolean isRolledUp(String column) {
-        return false;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public boolean rolledUpColumnValidInsideAgg(String column, SqlCall call,
-            @Nullable SqlNode parent,
-            @Nullable CalciteConnectionConfig config) {
-        return false;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public Statistic getStatistic() {
-        return statistic;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public <C> @Nullable C unwrap(Class<C> cls) {
-        if (cls.isInstance(desc)) {
-            return cls.cast(desc);
-        }
-
-        return super.unwrap(cls);
+    public Map<String, IgniteIndex> indexes() {
+        return indexMap;
     }
 
     /** {@inheritDoc} */
     @Override
-    public Map<String, IgniteIndex> indexes() {
-        return indexMap;
+    protected TableScan toRel(RelOptCluster cluster, RelTraitSet traitSet, RelOptTable relOptTbl, List<RelHint> hints) {
+        return IgniteLogicalTableScan.create(cluster, traitSet, hints, relOptTbl, null, null, null);
     }
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/IgniteResource.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/IgniteResource.java
index 3f2021c0d1..699ec60958 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/IgniteResource.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/IgniteResource.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.sql.engine.util;
 
 import org.apache.calcite.runtime.Resources;
+import org.apache.calcite.runtime.Resources.ExInst;
 import org.apache.calcite.sql.validate.SqlValidatorException;
 
 /**
@@ -47,4 +48,7 @@ public interface IgniteResource {
 
     @Resources.BaseMessage("Assignment from {0} to {1} can not be performed. Dynamic parameter requires adding explicit type cast")
     Resources.ExInst<SqlValidatorException> assignmentRequiresExplicitCast(String type1, String type2);
+
+    @Resources.BaseMessage("System view {0} is not modifiable")
+    ExInst<SqlValidatorException> systemViewIsNotModifiable(String systemViewName);
 }
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 7d46959300..55b5638282 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
@@ -74,6 +74,7 @@ import org.apache.ignite.internal.sql.engine.exec.rel.Outbox;
 import org.apache.ignite.internal.sql.engine.exec.rel.ScanNode;
 import org.apache.ignite.internal.sql.engine.framework.ArrayRowHandler;
 import org.apache.ignite.internal.sql.engine.framework.NoOpTransaction;
+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.message.ExecutionContextAwareMessage;
 import org.apache.ignite.internal.sql.engine.message.MessageListener;
@@ -87,8 +88,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.prepare.QueryPlan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan;
+import org.apache.ignite.internal.sql.engine.schema.CatalogColumnDescriptor;
 import org.apache.ignite.internal.sql.engine.schema.ColumnDescriptor;
-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.IgniteSchema;
 import org.apache.ignite.internal.sql.engine.schema.SqlSchemaManager;
@@ -114,6 +115,7 @@ import org.apache.ignite.network.ClusterNodeImpl;
 import org.apache.ignite.network.NetworkAddress;
 import org.apache.ignite.network.NetworkMessage;
 import org.apache.ignite.network.TopologyService;
+import org.apache.ignite.sql.ColumnType;
 import org.jetbrains.annotations.Nullable;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -139,8 +141,13 @@ public class ExecutionServiceImplTest extends BaseIgniteAbstractTest {
             nodeNames.get(2), List.of(new Object[]{2, 2}, new Object[]{5, 5}, new Object[]{8, 8})
     );
 
-    private final TestTable table = createTable("TEST_TBL", 1_000_000, IgniteDistributions.random(),
-            "ID", NativeTypes.INT32, "VAL", NativeTypes.INT32);
+    private final TestTable table = TestBuilders.table()
+            .name("TEST_TBL")
+            .addColumn("ID", NativeTypes.INT32)
+            .addColumn("VAL", NativeTypes.INT32)
+            .distribution(IgniteDistributions.random())
+            .size(1_000_000)
+            .build();
 
     private final IgniteSchema schema = new IgniteSchema(DEFAULT_SCHEMA_NAME, SCHEMA_VERSION, List.of(table));
 
@@ -867,10 +874,13 @@ public class ExecutionServiceImplTest extends BaseIgniteAbstractTest {
         List<ColumnDescriptor> columns = new ArrayList<>();
 
         for (int i = 0; i < fields.length; i += 2) {
+            NativeType nativeType = (NativeType) fields[i + 1];
+            ColumnType columnType = nativeType.spec().asColumnType();
+
             columns.add(
-                    new ColumnDescriptorImpl(
+                    new CatalogColumnDescriptor(
                             (String) fields[i], false, true, i,
-                            (NativeType) fields[i + 1], DefaultValueStrategy.DEFAULT_NULL, null
+                            columnType, 0, 0, 0, DefaultValueStrategy.DEFAULT_NULL, null
                     )
             );
         }
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 5c0ba6b617..ecb30b6cba 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
@@ -24,45 +24,22 @@ 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;
-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.Schema;
-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.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.schema.IgniteTableImpl;
 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.type.IgniteTypeFactory;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * A test table that implements all the necessary for the optimizer methods to be used to prepare a query, as well as provides access to the
  * data to use this table in execution-related scenarios.
  */
-public class TestTable implements IgniteTable {
+public class TestTable extends IgniteTableImpl {
     private static final String DATA_PROVIDER_NOT_CONFIGURED_MESSAGE_TEMPLATE =
             "DataProvider is not configured [table={}, node={}]";
 
     private static final AtomicInteger ID = new AtomicInteger();
 
-    private final int id = ID.incrementAndGet();
-    private final Map<String, IgniteIndex> indexes;
-
-    private final String name;
-    private final double rowCnt;
-    private final TableDescriptor descriptor;
     private final Map<String, DataProvider<?>> dataProviders;
 
-
     /** Constructor. */
     public TestTable(
             TableDescriptor descriptor,
@@ -81,11 +58,10 @@ public class TestTable implements IgniteTable {
             List<IgniteIndex> indexList,
             Map<String, DataProvider<?>> dataProviders
     ) {
-        this.descriptor = descriptor;
-        this.name = name;
-        this.rowCnt = rowCnt;
+        super(name, ID.incrementAndGet(), 1, descriptor, new TestStatistic(rowCnt),
+                indexList.stream().collect(Collectors.toUnmodifiableMap(IgniteIndex::name, Function.identity())));
+
         this.dataProviders = dataProviders;
-        indexes = indexList.stream().collect(Collectors.toUnmodifiableMap(IgniteIndex::name, Function.identity()));
     }
 
     /**
@@ -98,93 +74,9 @@ public class TestTable implements IgniteTable {
      */
     <RowT> DataProvider<RowT> dataProvider(String nodeName) {
         if (!dataProviders.containsKey(nodeName)) {
-            throw new AssertionError(format(DATA_PROVIDER_NOT_CONFIGURED_MESSAGE_TEMPLATE, name, nodeName));
+            throw new AssertionError(format(DATA_PROVIDER_NOT_CONFIGURED_MESSAGE_TEMPLATE, name(), nodeName));
         }
 
         return (DataProvider<RowT>) dataProviders.get(nodeName);
     }
-
-    /** {@inheritDoc} */
-    @Override
-    public int id() {
-        return id;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public int version() {
-        return 0;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteLogicalTableScan toRel(
-            RelOptCluster cluster,
-            RelOptTable relOptTbl,
-            List<RelHint> hints,
-            @Nullable List<RexNode> proj,
-            @Nullable RexNode cond,
-            @Nullable ImmutableBitSet requiredColumns
-    ) {
-        return IgniteLogicalTableScan.create(cluster, cluster.traitSet(), hints, relOptTbl, proj, cond, requiredColumns);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public RelDataType getRowType(RelDataTypeFactory typeFactory, ImmutableBitSet bitSet) {
-        return descriptor.rowType((IgniteTypeFactory) typeFactory, bitSet);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public Statistic getStatistic() {
-        return new TestStatistic(rowCnt);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public Schema.TableType getJdbcTableType() {
-        throw new AssertionError();
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public boolean isRolledUp(String col) {
-        return false;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public boolean rolledUpColumnValidInsideAgg(
-            String column,
-            SqlCall call,
-            SqlNode parent,
-            CalciteConnectionConfig config
-    ) {
-        throw new AssertionError();
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public IgniteDistribution distribution() {
-        return descriptor.distribution();
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public TableDescriptor descriptor() {
-        return descriptor;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public Map<String, IgniteIndex> indexes() {
-        return indexes;
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public String name() {
-        return name;
-    }
 }
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 f3e28539ec..7f007b297a 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
@@ -89,6 +89,7 @@ import org.apache.ignite.internal.sql.engine.prepare.Splitter;
 import org.apache.ignite.internal.sql.engine.prepare.bounds.SearchBounds;
 import org.apache.ignite.internal.sql.engine.rel.IgniteIndexScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteRel;
+import org.apache.ignite.internal.sql.engine.rel.IgniteSystemViewScan;
 import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan;
 import org.apache.ignite.internal.sql.engine.schema.ColumnDescriptor;
 import org.apache.ignite.internal.sql.engine.schema.DefaultValueStrategy;
@@ -517,6 +518,24 @@ public abstract class AbstractPlannerTest extends IgniteAbstractTest {
                 });
     }
 
+    /**
+     * Predicate builder for "Table scan with given name" condition.
+     */
+    protected <T extends RelNode> Predicate<IgniteSystemViewScan> isSystemViewScan(String viewName) {
+        return isInstanceOf(IgniteSystemViewScan.class).and(
+                n -> {
+                    String scanViewName = Util.last(n.getTable().getQualifiedName());
+
+                    if (viewName.equalsIgnoreCase(scanViewName)) {
+                        return true;
+                    }
+
+                    lastErrorMsg = "Unexpected system view name [exp=" + viewName + ", act=" + scanViewName + ']';
+
+                    return false;
+                });
+    }
+
     /**
      * Predicate builder for "Operator has distribution" condition.
      */
diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/SystemViewPlannerTest.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/SystemViewPlannerTest.java
new file mode 100644
index 0000000000..f566c1cf01
--- /dev/null
+++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/SystemViewPlannerTest.java
@@ -0,0 +1,172 @@
+/*
+ * 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.planner;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.runtime.CalciteContextException;
+import org.apache.calcite.util.ImmutableBitSet;
+import org.apache.ignite.internal.sql.engine.rel.IgniteSystemViewScan;
+import org.apache.ignite.internal.sql.engine.schema.CatalogColumnDescriptor;
+import org.apache.ignite.internal.sql.engine.schema.ColumnDescriptor;
+import org.apache.ignite.internal.sql.engine.schema.DefaultValueStrategy;
+import org.apache.ignite.internal.sql.engine.schema.IgniteSchema;
+import org.apache.ignite.internal.sql.engine.schema.IgniteSystemView;
+import org.apache.ignite.internal.sql.engine.schema.IgniteSystemViewImpl;
+import org.apache.ignite.internal.sql.engine.schema.TableDescriptorImpl;
+import org.apache.ignite.internal.sql.engine.trait.IgniteDistributions;
+import org.apache.ignite.sql.ColumnType;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+/**
+ * Planner test for system views.
+ */
+public class SystemViewPlannerTest extends AbstractPlannerTest {
+
+    private static final AtomicInteger SYSTEM_VIEW_ID = new AtomicInteger();
+
+    @Test
+    public void testReadAllColumns() throws Exception {
+        IgniteSystemView propsView = systemPropsView("SYS_PROPS", "KEY", "VAL");
+
+        assertPlan("SELECT * FROM SYS_PROPS", createSystemSchema(propsView),
+                isSystemViewScan("SYS_PROPS").and(v -> ImmutableBitSet.of(0, 1).equals(v.requiredColumns())));
+    }
+
+    @Test
+    public void testPruneColumns() throws Exception {
+        IgniteSystemView propsView = systemPropsView("SYS_PROPS", "KEY", "VAL");
+
+        IgniteSchema schema = createSystemSchema(propsView);
+
+        assertPlan("SELECT key FROM SYS_PROPS", schema,
+                isSystemViewScan("SYS_PROPS").and(v -> ImmutableBitSet.of(0).equals(v.requiredColumns())));
+
+        assertPlan("SELECT val FROM SYS_PROPS", schema,
+                isSystemViewScan("SYS_PROPS").and(v -> ImmutableBitSet.of(1).equals(v.requiredColumns())));
+    }
+
+    @Test
+    public void testFilterPushDown() throws Exception {
+        IgniteSystemView propsView = systemPropsView("SYS_PROPS", "KEY", "VAL");
+        IgniteSchema schema = createSystemSchema(propsView);
+
+        assertPlan("SELECT * FROM SYS_PROPS WHERE key like 'os%'", schema,
+                isSystemViewScan("SYS_PROPS")
+                        .and(hasExpr(IgniteSystemViewScan::condition, "LIKE($t0, _UTF-8'os%')")));
+    }
+
+    @Test
+    public void testProjectionPushDown() throws Exception {
+        IgniteSystemView propsView = systemPropsView("SYS_PROPS", "KEY", "VAL");
+
+        IgniteSchema schema = createSystemSchema(propsView);
+
+        assertPlan("SELECT key, SUBSTRING(val, 1) FROM SYS_PROPS", schema,
+                isSystemViewScan("SYS_PROPS")
+                        .and(hasExprs(IgniteSystemViewScan::projects, "$t0", "SUBSTRING($t1, 1)")));
+    }
+
+    @Test
+    public void testPruneColumnsPushProjectionsAndFilters() throws Exception {
+        IgniteSystemView propsView = systemPropsView("USERS", "ID", "HOME", "NAME", "TTY");
+
+        IgniteSchema schema = createSystemSchema(propsView);
+
+        assertPlan("SELECT id, SUBSTRING(home, 4) FROM users WHERE name LIKE 'test%'", schema,
+                isSystemViewScan("USERS")
+                        .and(v -> ImmutableBitSet.of(0, 1, 2).equals(v.requiredColumns()))
+                        .and(hasExprs(IgniteSystemViewScan::projects, "$t0", "SUBSTRING($t1, 4)"))
+                        .and(hasExpr(IgniteSystemViewScan::condition, "LIKE($t2, _UTF-8'test%')")
+        ));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "INSERT INTO SYSTEM.SYS_PROPS VALUES('a', 'b')",
+            "INSERT into SYS_PROPS(key, VAL) VALUES('a', 'b')",
+            "UPDATE SYSTEM.SYS_PROPS SET val = '0000'",
+            "DELETE FROM SYSTEM.SYS_PROPS",
+            "MERGE INTO SYSTEM.SYS_PROPS dst USING SYSTEM.SYS_PROPS src ON dst.key = src.key "
+                    + "WHEN MATCHED THEN UPDATE SET val = 'x'"
+                    + "WHEN NOT MATCHED THEN INSERT (key, val) VALUES (src.key, src.val)"
+    })
+    public void testDmlOperationsAreNotAllowed(String sql) {
+        IgniteSystemView propsView = systemPropsView("SYS_PROPS", "KEY", "VAL");
+
+        CalciteContextException err = assertThrows(CalciteContextException.class, () -> {
+            physicalPlan(sql, createSystemSchema(propsView));
+        });
+        assertThat(err.getMessage(), containsString("System view SYSTEM.SYS_PROPS is not modifiable"));
+    }
+
+    private static IgniteSchema createSystemSchema(IgniteSystemView view) {
+        return new IgniteSchema("SYSTEM", 1, List.of(view));
+    }
+
+    private static IgniteSystemView systemPropsView(String name, String... columnNames) {
+        List<ColumnDescriptor> columns = new ArrayList<>(columnNames.length);
+
+        for (String columnName : columnNames) {
+            DefaultValueStrategy defaultNull = DefaultValueStrategy.DEFAULT_NULL;
+            columns.add(new CatalogColumnDescriptor(columnName, false, false, columns.size(),
+                    ColumnType.STRING, 0, 0, 100, defaultNull, null));
+        }
+
+        int id = SYSTEM_VIEW_ID.incrementAndGet();
+        TableDescriptorImpl tableDescriptor = new TableDescriptorImpl(columns, IgniteDistributions.single());
+
+        return new IgniteSystemViewImpl(name, id, 1, tableDescriptor);
+    }
+
+    private static <T extends RelNode> Predicate<T> hasExpr(Function<T, RexNode> expr, String... expectedExprs) {
+        return hasExprs((node) -> {
+            RexNode oneExpr = expr.apply(node);
+            if (oneExpr == null) {
+                return List.of();
+            } else {
+                return List.of(oneExpr);
+            }
+        }, expectedExprs);
+    }
+
+    private static <T extends RelNode> Predicate<T> hasExprs(Function<T, List<RexNode>> exprs, String... expectedExprs) {
+        return node -> {
+            List<RexNode> exprList = exprs.apply(node);
+
+            if (exprList == null) {
+                return expectedExprs.length == 0;
+            } else {
+                List<String> exprStrList = exprList.stream().map(RexNode::toString).collect(Collectors.toList());
+                return exprStrList.equals(List.of(expectedExprs));
+            }
+        };
+    }
+}
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 e15a52e0eb..55c07a6faf 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
@@ -35,13 +35,14 @@ import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.config.CalciteConnectionConfig;
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.plan.RelOptTable.ToRelContext;
+import org.apache.calcite.rel.core.TableScan;
 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.rel.type.RelDataTypeField;
 import org.apache.calcite.rel.type.RelDataTypeImpl;
 import org.apache.calcite.rel.type.RelProtoDataType;
-import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.runtime.CalciteContextException;
 import org.apache.calcite.schema.Schema;
 import org.apache.calcite.schema.Statistic;
@@ -560,7 +561,8 @@ public class TypeCoercionTest extends AbstractPlannerTest {
     }
 
     //TODO https://issues.apache.org/jira/browse/IGNITE-15200 Replace with TestTable from test framework.
-    // This class allows to verify some negative type-coercion tests, and can be dropped when INTERVAL type will be supported natively.
+    //TODO: https://issues.apache.org/jira/browse/IGNITE-17373: Remove when INTERVAL type will be supported natively,
+    // or this issue is resolved.
 
     /** Test table. */
     @Deprecated
@@ -589,18 +591,6 @@ public class TypeCoercionTest extends AbstractPlannerTest {
             return 0;
         }
 
-        @Override
-        public IgniteLogicalTableScan toRel(
-                RelOptCluster cluster,
-                RelOptTable relOptTbl,
-                List<RelHint> hints,
-                @Nullable List<RexNode> proj,
-                @Nullable RexNode cond,
-                @Nullable ImmutableBitSet requiredColumns
-        ) {
-            return IgniteLogicalTableScan.create(cluster, cluster.traitSet(), hints, relOptTbl, proj, cond, requiredColumns);
-        }
-
         /** {@inheritDoc} */
         @Override
         public RelDataType getRowType(RelDataTypeFactory typeFactory, ImmutableBitSet bitSet) {
@@ -617,6 +607,14 @@ public class TypeCoercionTest extends AbstractPlannerTest {
             return rowType;
         }
 
+        @Override
+        public TableScan toRel(ToRelContext context, RelOptTable relOptTable) {
+            RelOptCluster cluster = context.getCluster();
+            List<RelHint> hints = context.getTableHints();
+
+            return IgniteLogicalTableScan.create(cluster, cluster.traitSet(), hints, relOptTable, null, null, null);
+        }
+
         @Override
         public Statistic getStatistic() {
             return new TestStatistic(100.0);
@@ -656,5 +654,13 @@ public class TypeCoercionTest extends AbstractPlannerTest {
         public String name() {
             return name;
         }
+
+        @Override
+        public <C> @Nullable C unwrap(Class<C> cls) {
+            if (cls.isInstance(this)) {
+                return cls.cast(this);
+            }
+            return null;
+        }
     }
 }
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 c5d30091ce..1b1a71a1b5 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
@@ -22,6 +22,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.containsString;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -40,11 +41,13 @@ import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 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.schema.SchemaPlus;
+import org.apache.calcite.schema.Table;
 import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.catalog.commands.DefaultValue;
 import org.apache.ignite.internal.catalog.descriptors.CatalogColumnCollation;
@@ -54,6 +57,7 @@ import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogSchemaDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogSortedIndexDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogSystemViewDescriptor;
+import org.apache.ignite.internal.catalog.descriptors.CatalogSystemViewDescriptor.SystemViewType;
 import org.apache.ignite.internal.catalog.descriptors.CatalogTableColumnDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor;
 import org.apache.ignite.internal.schema.DefaultValueGenerator;
@@ -67,7 +71,8 @@ import org.apache.ignite.sql.ColumnType;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
@@ -116,36 +121,7 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest {
      * Table column types.
      */
     @ParameterizedTest
-    @CsvSource({
-            // column type, precision, scale, has native type.
-            "BOOLEAN, -1, -1, true",
-
-            "INT8, -1, -1, true",
-            "INT16, -1, -1, true",
-            "INT32, -1, -1, true",
-            "INT64, -1, -1, true",
-
-            "FLOAT, -1, -1, true",
-            "DOUBLE, -1, -1, true",
-
-            "DECIMAL, 4, -1, true",
-            "DECIMAL, 4, 2, true",
-            "NUMBER, 4, -1, true",
-
-            "STRING, 40, -1, true",
-            "BYTE_ARRAY, 40, -1, true",
-
-            "DATE, -1, -1, true",
-            "TIME, 2, -1, true",
-            "DATETIME, 2, -1, true",
-            "TIMESTAMP, 2, -1, true",
-
-            "PERIOD, 2, -1, false",
-            "DURATION, 2, -1, false",
-
-            "UUID, 2, -1, true",
-            "BITMASK, 2, -1, true"
-    })
+    @MethodSource("columnTypes")
     public void testTableColumns(ColumnType columnType, int precision, int scale, boolean hasNativeType) {
         TestTable testTable = new TestTable("TEST");
 
@@ -167,13 +143,18 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest {
         assertEquals(testTable.id, table.id());
         assertEquals(schema.version(), table.version());
 
-        assertEquals(testTable.columns.size(), table.descriptor().columnsCount(), "column count");
+        TableDescriptor descriptor = table.descriptor();
+        assertEquals(testTable.columns.size(), descriptor.columnsCount(), "column count");
+
+        checkColumns(columnType, precision, scale, hasNativeType, descriptor);
+    }
 
-        ColumnDescriptor c1 = table.descriptor().columnDescriptor(0);
+    private static void checkColumns(ColumnType columnType, int precision, int scale, boolean hasNativeType, TableDescriptor descriptor) {
+        ColumnDescriptor c1 = descriptor.columnDescriptor(0);
         assertEquals(0, c1.logicalIndex());
         assertTrue(c1.nullable());
 
-        ColumnDescriptor c2 = table.descriptor().columnDescriptor(1);
+        ColumnDescriptor c2 = descriptor.columnDescriptor(1);
         assertEquals(1, c2.logicalIndex());
         assertFalse(c2.nullable());
 
@@ -347,6 +328,7 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest {
         // TODO Use the actual zone ID after implementing https://issues.apache.org/jira/browse/IGNITE-18426.
         int tableId = table.id();
         assertEquals(IgniteDistributions.affinity(List.of(1, 2), tableId, tableId), distribution);
+        assertEquals(distribution, table.getStatistic().getDistribution());
     }
 
     /**
@@ -432,6 +414,92 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest {
         ), testIdx.collation());
     }
 
+    /**
+     * Tests basic properties of a system view.
+     */
+    @ParameterizedTest
+    @MethodSource("systemViewDistributions")
+    public void testBasicView(SystemViewType viewType, IgniteDistribution distribution) {
+        TestSystemView testSystemView = new TestSystemView("TEST", viewType);
+        testSystemView.addColumn("c1", ColumnType.STRING);
+
+        TestSchema testSchema = new TestSchema();
+        testSchema.systemViews.add(testSystemView);
+        testSchema.init(catalogManager);
+
+        SqlSchemaManager sqlSchemaManager = newSchemaManager();
+        SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
+        IgniteSchema igniteSchema = unwrapSchema(schemaPlus);
+        IgniteSystemView systemView = getSystemView(igniteSchema, testSystemView);
+
+        assertEquals(testSystemView.id, systemView.id());
+        assertEquals(distribution, systemView.distribution());
+        assertEquals(distribution, systemView.getStatistic().getDistribution());
+    }
+
+    /**
+     * Tests system view column types.
+     */
+    @ParameterizedTest
+    @MethodSource("systemViewColumnTypes")
+    public void testViewColumns(SystemViewType viewType, ColumnType columnType, int precision, int scale, boolean hasNativeType) {
+        TestSystemView testSystemView = new TestSystemView("TEST", viewType);
+
+        testSystemView.addColumn("c1_nullable", columnType, precision, scale);
+        testSystemView.addColumn("c1_not_nullable", columnType, precision, scale);
+
+        testSystemView.notNull("c1_not_nullable");
+
+        TestSchema testSchema = new TestSchema();
+        testSchema.systemViews.add(testSystemView);
+        testSchema.init(catalogManager);
+
+        SqlSchemaManager sqlSchemaManager = newSchemaManager();
+        SchemaPlus schemaPlus = sqlSchemaManager.schema(testSchema.name, testSchema.timestamp);
+        IgniteSchema igniteSchema = unwrapSchema(schemaPlus);
+        IgniteSystemView systemView = getSystemView(igniteSchema, testSystemView);
+
+        TableDescriptor descriptor = systemView.descriptor();
+        assertEquals(testSystemView.columns.size(), descriptor.columnsCount(), "column count");
+    }
+
+    private static Stream<Arguments> systemViewColumnTypes() {
+        List<Arguments> allArgs = new ArrayList<>();
+
+        for (SystemViewType type : SystemViewType.values()) {
+            columnTypes().map(args -> {
+                Object[] vals = args.get();
+
+                Object[] newVals = new Object[vals.length + 1];
+                newVals[0] = type;
+
+                System.arraycopy(vals, 0, newVals, 1, vals.length);
+
+                return Arguments.of(newVals);
+            }).forEach(allArgs::add);
+        }
+
+        return allArgs.stream();
+    }
+
+    private static Stream<Arguments> systemViewDistributions() {
+        return Stream.of(
+                Arguments.of(SystemViewType.LOCAL, IgniteDistributions.identity(0)),
+                Arguments.of(SystemViewType.GLOBAL, IgniteDistributions.single())
+        );
+    }
+
+
+    private static IgniteSystemView getSystemView(IgniteSchema schema, TestSystemView testSystemView) {
+        Table systemViewTable = schema.getTable(testSystemView.name);
+        assertNotNull(systemViewTable);
+
+        IgniteSystemView systemView = assertInstanceOf(IgniteSystemView.class, systemViewTable);
+        assertEquals(systemView.name(), testSystemView.name);
+
+        return systemView;
+    }
+
     private CatalogSqlSchemaManager newSchemaManager() {
         return new CatalogSqlSchemaManager(catalogManager, 200);
     }
@@ -448,6 +516,31 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest {
         return table;
     }
 
+    private static Stream<Arguments> columnTypes() {
+        return Stream.of(
+                Arguments.of(ColumnType.BOOLEAN, -1, -1, true),
+                Arguments.of(ColumnType.INT8, -1, -1, true),
+                Arguments.of(ColumnType.INT16, -1, -1, true),
+                Arguments.of(ColumnType.INT32, -1, -1, true),
+                Arguments.of(ColumnType.INT64, -1, -1, true),
+                Arguments.of(ColumnType.FLOAT, -1, -1, true),
+                Arguments.of(ColumnType.DOUBLE, -1, -1, true),
+                Arguments.of(ColumnType.DECIMAL, 4, -1, true),
+                Arguments.of(ColumnType.DECIMAL, 4, 2, true),
+                Arguments.of(ColumnType.NUMBER, 4, -1, true),
+                Arguments.of(ColumnType.STRING, 40, -1, true),
+                Arguments.of(ColumnType.BYTE_ARRAY, 40, -1, true),
+                Arguments.of(ColumnType.DATE, -1, -1, true),
+                Arguments.of(ColumnType.TIME, 2, -1, true),
+                Arguments.of(ColumnType.DATETIME, 2, -1, true),
+                Arguments.of(ColumnType.TIMESTAMP, 2, -1, true),
+                Arguments.of(ColumnType.PERIOD, 2, -1, false),
+                Arguments.of(ColumnType.DURATION, 2, -1, false),
+                Arguments.of(ColumnType.UUID, 2, -1, true),
+                Arguments.of(ColumnType.BITMASK, 2, -1, true)
+        );
+    }
+
     private static final class TestSchema {
 
         final String name;
@@ -456,6 +549,8 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest {
 
         final Set<TestIndex> indexes = new LinkedHashSet<>();
 
+        final Set<TestSystemView> systemViews = new LinkedHashSet<>();
+
         TestSchema() {
             this(DEFAULT_SCHEMA_NAME);
         }
@@ -496,35 +591,35 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest {
                 indexDescriptorMap.put(name, testIndex.newDescriptor(tableId));
             }
 
+            LinkedHashMap<String, CatalogSystemViewDescriptor> systemViewDescriptorMap = new LinkedHashMap<>();
+
+            for (TestSystemView testSystemView : systemViews) {
+                CatalogSystemViewDescriptor descriptor = testSystemView.newDescriptor(testSystemView.id);
+
+                systemViewDescriptorMap.put(testSystemView.name, descriptor);
+            }
+
             CatalogTableDescriptor[] tablesArray = tableDescriptors.values().toArray(new CatalogTableDescriptor[0]);
             CatalogIndexDescriptor[] indexesArray = indexDescriptorMap.values().toArray(new CatalogIndexDescriptor[0]);
-            CatalogSystemViewDescriptor[] systemViewsArray = new CatalogSystemViewDescriptor[0];
+            CatalogSystemViewDescriptor[] systemViewsArray = systemViewDescriptorMap.values().toArray(new CatalogSystemViewDescriptor[0]);
 
             return new CatalogSchemaDescriptor(ID.incrementAndGet(), name, tablesArray, indexesArray, systemViewsArray);
         }
     }
 
-    private static final class TestTable {
-
-        private final List<CatalogTableColumnDescriptor> columns = new ArrayList<>();
-
-        private int id = ID.incrementAndGet();
+    private abstract static class TestDataSource {
 
-        private final String name;
+        final List<CatalogTableColumnDescriptor> columns = new ArrayList<>();
 
-        private final int zoneId = ID.incrementAndGet();
+        int id = ID.incrementAndGet();
 
-        private final Set<String> notNull = new HashSet<>();
+        final String name;
 
-        private List<String> primaryKey = Collections.emptyList();
+        final Set<String> notNull = new HashSet<>();
 
-        private List<String> colocationKey;
+        final Map<String, DefaultValue> defaultValueMap = new HashMap<>();
 
-        private final Map<String, DefaultValue> defaultValueMap = new HashMap<>();
-
-        private int version;
-
-        private TestTable(String name) {
+        TestDataSource(String name) {
             this.name = name;
         }
 
@@ -549,6 +644,21 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest {
             notNull.clear();
             notNull.addAll(Arrays.asList(names));
         }
+    }
+
+    private static final class TestTable extends TestDataSource {
+
+        private final int zoneId = ID.incrementAndGet();
+
+        private List<String> primaryKey = Collections.emptyList();
+
+        private List<String> colocationKey;
+
+        private int version;
+
+        private TestTable(String name) {
+            super(name);
+        }
 
         // Sets primary key columns
         void primaryKey(String... names) {
@@ -621,4 +731,18 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest {
             }
         }
     }
+
+    private static class TestSystemView extends TestDataSource {
+
+        final SystemViewType systemViewType;
+
+        private TestSystemView(String name, SystemViewType systemViewType) {
+            super(name);
+            this.systemViewType = systemViewType;
+        }
+
+        CatalogSystemViewDescriptor newDescriptor(int id) {
+            return new CatalogSystemViewDescriptor(id, name, List.copyOf(columns), systemViewType);
+        }
+    }
 }