Merge ITableDeclaration into IStorage.

Also a couple of massive include-refactorings with better forwarding

dbms/src/Client/Connection.h

@@ -12,8 +12,7 @@
 #include <Core/Protocol.h>
 #include <Core/QueryProcessingStage.h>
 
-#include <DataStreams/IBlockInputStream.h>
-#include <DataStreams/IBlockOutputStream.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <DataStreams/BlockStreamProfileInfo.h>
 
 #include <IO/ConnectionTimeouts.h>

dbms/src/DataStreams/BlockIO.h

 #pragma once
 
-#include <DataStreams/IBlockInputStream.h>
-#include <DataStreams/IBlockOutputStream.h>
+#include <DataStreams/IBlockStream_fwd.h>
 
 
 namespace DB

dbms/src/DataStreams/BlockStreamProfileInfo.h

 #pragma once
 
-#include <vector>
-#include <Common/Stopwatch.h>
 #include <Core/Types.h>
+#include <DataStreams/IBlockStream_fwd.h>
+#include <Common/Stopwatch.h>
+
+#include <vector>
 
 namespace DB
 {
@@ -10,7 +12,6 @@ namespace DB
 class Block;
 class ReadBuffer;
 class WriteBuffer;
-class IBlockInputStream;
 
 /// Information for profiling. See IBlockInputStream.h
 struct BlockStreamProfileInfo

dbms/src/DataStreams/IBlockInputStream.h

@@ -2,6 +2,7 @@
 
 #include <Core/Block.h>
 #include <Core/SortDescription.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <DataStreams/BlockStreamProfileInfo.h>
 #include <DataStreams/SizeLimits.h>
 #include <IO/Progress.h>
@@ -21,14 +22,10 @@ namespace ErrorCodes
     extern const int QUERY_WAS_CANCELLED;
 }
 
-class IBlockInputStream;
 class ProcessListElement;
 class QuotaForIntervals;
 class QueryStatus;
 
-using BlockInputStreamPtr = std::shared_ptr<IBlockInputStream>;
-using BlockInputStreams = std::vector<BlockInputStreamPtr>;
-
 /** Callback to track the progress of the query.
   * Used in IBlockInputStream and Context.
   * The function takes the number of rows in the last block, the number of bytes in the last block.

dbms/src/DataStreams/IBlockOutputStream.h

 #pragma once
 
-#include <string>
-#include <vector>
-#include <memory>
-#include <boost/noncopyable.hpp>
 #include <Core/Block.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <Storages/TableStructureLockHolder.h>
 
+#include <boost/noncopyable.hpp>
+
+#include <memory>
+#include <string>
+#include <vector>
+
 
 namespace DB
 {
@@ -64,6 +67,4 @@ private:
     std::vector<TableStructureReadLockHolder> table_locks;
 };
 
-using BlockOutputStreamPtr = std::shared_ptr<IBlockOutputStream>;
-
 }

dbms/src/DataStreams/IBlockStream_fwd.h

+#pragma once
+
+#include <memory>
+#include <vector>
+
+namespace DB
+{
+
+class IBlockInputStream;
+class IBlockOutputStream;
+
+using BlockInputStreamPtr = std::shared_ptr<IBlockInputStream>;
+using BlockInputStreams = std::vector<BlockInputStreamPtr>;
+using BlockOutputStreamPtr = std::shared_ptr<IBlockOutputStream>;
+
+}

dbms/src/DataStreams/ParallelInputsProcessor.h

@@ -8,7 +8,7 @@
 
 #include <common/logger_useful.h>
 
-#include <DataStreams/IBlockInputStream.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <Common/setThreadName.h>
 #include <Common/CurrentMetrics.h>
 #include <Common/CurrentThread.h>

dbms/src/DataStreams/copyData.h

 #pragma once
 
+#include <DataStreams/IBlockStream_fwd.h>
+
 #include <atomic>
 #include <functional>
 
@@ -7,8 +9,6 @@
 namespace DB
 {
 
-class IBlockInputStream;
-class IBlockOutputStream;
 class Block;
 
 /** Copies data from the InputStream into the OutputStream

dbms/src/Databases/DatabaseDictionary.h

@@ -4,7 +4,7 @@
 #include <unordered_set>
 #include <Databases/DatabasesCommon.h>
 #include <Databases/IDatabase.h>
-#include <Storages/IStorage.h>
+#include <Storages/IStorage_fwd.h>
 
 
 namespace Poco

dbms/src/Databases/DatabaseOrdinary.cpp

 #include <iomanip>
 
-#include <Poco/Event.h>
-#include <Poco/DirectoryIterator.h>
-#include <common/logger_useful.h>
-
-#include <Databases/DatabaseOrdinary.h>
+#include <Core/Settings.h>
 #include <Databases/DatabaseMemory.h>
+#include <Databases/DatabaseOrdinary.h>
 #include <Databases/DatabasesCommon.h>
-#include <Common/typeid_cast.h>
-#include <Common/escapeForFileName.h>
-#include <Common/StringUtils/StringUtils.h>
-#include <Common/Stopwatch.h>
-#include <Common/ThreadPool.h>
-#include <Parsers/ASTCreateQuery.h>
-#include <Parsers/parseQuery.h>
-#include <Parsers/ParserCreateQuery.h>
-#include <Interpreters/Context.h>
-#include <Core/Settings.h>
-#include <Interpreters/InterpreterCreateQuery.h>
-#include <IO/WriteBufferFromFile.h>
 #include <IO/ReadBufferFromFile.h>
-#include <IO/WriteHelpers.h>
 #include <IO/ReadHelpers.h>
+#include <IO/WriteBufferFromFile.h>
+#include <IO/WriteHelpers.h>
+#include <Interpreters/Context.h>
+#include <Interpreters/InterpreterCreateQuery.h>
+#include <Parsers/ASTCreateQuery.h>
+#include <Parsers/ParserCreateQuery.h>
+#include <Parsers/parseQuery.h>
+#include <Storages/IStorage.h>
+
+#include <Poco/DirectoryIterator.h>
+#include <Poco/Event.h>
+#include <Common/Stopwatch.h>
+#include <Common/StringUtils/StringUtils.h>
+#include <Common/ThreadPool.h>
+#include <Common/escapeForFileName.h>
+#include <Common/typeid_cast.h>
+#include <common/logger_useful.h>
 #include <ext/scope_guard.h>
 
 

dbms/src/Databases/DatabasesCommon.cpp

-#include <sstream>
+#include <Databases/DatabasesCommon.h>
 
-#include <Common/typeid_cast.h>
-#include <Parsers/parseQuery.h>
-#include <Parsers/ParserCreateQuery.h>
-#include <Parsers/ASTCreateQuery.h>
-#include <Parsers/formatAST.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/InterpreterCreateQuery.h>
+#include <Parsers/ASTCreateQuery.h>
+#include <Parsers/ParserCreateQuery.h>
+#include <Parsers/formatAST.h>
+#include <Parsers/parseQuery.h>
+#include <Storages/IStorage.h>
 #include <Storages/StorageFactory.h>
-#include <Databases/DatabasesCommon.h>
+#include <Common/typeid_cast.h>
+
+#include <sstream>
 
 
 namespace DB

dbms/src/Databases/DatabasesCommon.h

@@ -2,7 +2,7 @@
 
 #include <Core/Types.h>
 #include <Parsers/IAST.h>
-#include <Storages/IStorage.h>
+#include <Storages/IStorage_fwd.h>
 #include <Databases/IDatabase.h>
 
 

dbms/src/Databases/IDatabase.h

@@ -6,6 +6,7 @@
 #include <Parsers/IAST_fwd.h>
 #include <Storages/ColumnsDescription.h>
 #include <Storages/IndicesDescription.h>
+#include <Storages/IStorage_fwd.h>
 #include <Poco/File.h>
 #include <Common/ThreadPool.h>
 #include <Common/escapeForFileName.h>
@@ -20,9 +21,6 @@ namespace DB
 
 class Context;
 
-class IStorage;
-using StoragePtr = std::shared_ptr<IStorage>;
-
 struct Settings;
 
 

dbms/src/Dictionaries/CacheDictionary.inc.h

@@ -3,6 +3,7 @@
 #include <Columns/ColumnsNumber.h>
 #include <Common/ProfilingScopedRWLock.h>
 #include <Common/typeid_cast.h>
+#include <DataStreams/IBlockInputStream.h>
 #include <ext/map.h>
 #include <ext/range.h>
 #include <ext/size.h>

dbms/src/Dictionaries/ComplexKeyCacheDictionary.h

@@ -20,6 +20,7 @@
 #include "DictionaryStructure.h"
 #include "IDictionary.h"
 #include "IDictionarySource.h"
+#include <DataStreams/IBlockInputStream.h>
 
 
 namespace ProfileEvents

dbms/src/Dictionaries/ComplexKeyHashedDictionary.h

@@ -7,6 +7,7 @@
 #include <Columns/ColumnString.h>
 #include <Common/Arena.h>
 #include <Common/HashTable/HashMap.h>
+#include <Core/Block.h>
 #include <common/StringRef.h>
 #include <ext/range.h>
 #include "DictionaryStructure.h"

dbms/src/Dictionaries/DictionarySourceFactory.h

 #pragma once
 
 #include "IDictionarySource.h"
+#include <Core/Block.h>
 
 #include <unordered_map>
 #include <ext/singleton.h>

dbms/src/Dictionaries/ExecutableDictionarySource.h

@@ -2,12 +2,10 @@
 
 #include "DictionaryStructure.h"
 #include "IDictionarySource.h"
+#include <Core/Block.h>
 
 
-namespace Poco
-{
-class Logger;
-}
+namespace Poco { class Logger; }
 
 
 namespace DB

dbms/src/Dictionaries/FileDictionarySource.h

@@ -2,6 +2,7 @@
 
 #include <Poco/Timestamp.h>
 #include "IDictionarySource.h"
+#include <Core/Block.h>
 
 
 namespace DB

dbms/src/Dictionaries/FlatDictionary.h

@@ -6,6 +6,7 @@
 #include <Columns/ColumnDecimal.h>
 #include <Columns/ColumnString.h>
 #include <Common/Arena.h>
+#include <Core/Block.h>
 #include <ext/range.h>
 #include <ext/size.h>
 #include "DictionaryStructure.h"

dbms/src/Dictionaries/HashedDictionary.h

@@ -5,6 +5,7 @@
 #include <variant>
 #include <Columns/ColumnDecimal.h>
 #include <Columns/ColumnString.h>
+#include <Core/Block.h>
 #include <Common/HashTable/HashMap.h>
 #include <ext/range.h>
 #include "DictionaryStructure.h"

dbms/src/Dictionaries/IDictionary.h

 #pragma once
 
-#include <chrono>
-#include <memory>
+
 #include <Core/Field.h>
 #include <Core/Names.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <Interpreters/IExternalLoadable.h>
 #include <Poco/Util/XMLConfiguration.h>
 #include <Common/PODArray.h>
 #include <common/StringRef.h>
 #include "IDictionarySource.h"
 
+#include <chrono>
+#include <memory>
+
 namespace DB
 {
+
 struct IDictionaryBase;
 using DictionaryPtr = std::unique_ptr<IDictionaryBase>;
 
 struct DictionaryStructure;
 class ColumnString;
 
-class IBlockInputStream;
-using BlockInputStreamPtr = std::shared_ptr<IBlockInputStream>;
-
-
 struct IDictionaryBase : public IExternalLoadable
 {
     using Key = UInt64;

dbms/src/Dictionaries/IDictionarySource.h

 #pragma once
 
+#include <Columns/IColumn.h>
+#include <DataStreams/IBlockStream_fwd.h>
+
 #include <vector>
-#include <DataStreams/IBlockInputStream.h>
 
 
 namespace DB

dbms/src/Dictionaries/MongoDBDictionarySource.h

 #pragma once
 
 #include <Common/config.h>
+#include <Core/Block.h>
 #if USE_POCO_MONGODB
 
 #    include "DictionaryStructure.h"

dbms/src/Dictionaries/MySQLDictionarySource.h

 #pragma once
 
 #include <Common/config.h>
+#include <Core/Block.h>
 #if USE_MYSQL
 
 #    include <common/LocalDateTime.h>

dbms/src/Dictionaries/readInvalidateQuery.h

 #pragma once
+
+#include <DataStreams/IBlockStream_fwd.h>
+
 #include <string>
 
 namespace DB
 {
 
-class IBlockInputStream;
-
 /// Using in MySQLDictionarySource and XDBCDictionarySource after processing invalidate_query.
 std::string readInvalidateQuery(IBlockInputStream & block_input_stream);
 

dbms/src/Formats/FormatFactory.h

 #pragma once
 
-#include <memory>
+#include <Core/Types.h>
+#include <DataStreams/IBlockStream_fwd.h>
+#include <ext/singleton.h>
+
 #include <functional>
+#include <memory>
 #include <unordered_map>
-#include <ext/singleton.h>
-#include <Core/Types.h>
 
 
 namespace DB
@@ -17,13 +19,6 @@ struct FormatSettings;
 class ReadBuffer;
 class WriteBuffer;
 
-class IBlockInputStream;
-class IBlockOutputStream;
-
-using BlockInputStreamPtr = std::shared_ptr<IBlockInputStream>;
-using BlockOutputStreamPtr = std::shared_ptr<IBlockOutputStream>;
-
-
 /** Allows to create an IBlockInputStream or IBlockOutputStream by the name of the format.
   * Note: format and compression are independent things.
   */

dbms/src/Functions/FunctionJoinGet.h

 #include <Functions/IFunction.h>
+#include <Storages/IStorage_fwd.h>
 #include <Storages/TableStructureLockHolder.h>
 
 namespace DB
 {
 class Context;
-class IStorage;
-using StoragePtr = std::shared_ptr<IStorage>;
 class Join;
 using JoinPtr = std::shared_ptr<Join>;
 

dbms/src/Interpreters/ActionLocksManager.h

 #pragma once
+
 #include <Core/Types.h>
+#include <Storages/IStorage_fwd.h>
 #include <Common/ActionLock.h>
-#include <unordered_map>
+
 #include <mutex>
+#include <unordered_map>
 
 
 namespace DB
 {
 
-class IStorage;
 class Context;
 
 /// Holds ActionLocks for tables

dbms/src/Interpreters/Aggregator.h

@@ -18,7 +18,7 @@
 #include <Common/LRUCache.h>
 #include <Common/ColumnsHashing.h>
 
-#include <DataStreams/IBlockInputStream.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <DataStreams/SizeLimits.h>
 
 #include <Interpreters/AggregateDescription.h>

dbms/src/Interpreters/ClusterProxy/IStreamFactory.h

 #pragma once
 
+#include <Client/ConnectionPool.h>
 #include <Interpreters/Cluster.h>
 #include <Parsers/IAST.h>
-#include <Storages/IStorage.h>
-#include <Client/ConnectionPool.h>
 
 namespace DB
 {

dbms/src/Interpreters/ClusterProxy/SelectStreamFactory.h

 #pragma once
 
-#include <Interpreters/ClusterProxy/IStreamFactory.h>
 #include <Core/QueryProcessingStage.h>
-#include <Storages/IStorage.h>
+#include <Interpreters/ClusterProxy/IStreamFactory.h>
+#include <Storages/IStorage_fwd.h>
 
 namespace DB
 {

dbms/src/Interpreters/ClusterProxy/executeQuery.h

 #pragma once
 
 #include <Parsers/IAST.h>
-#include <Storages/IStorage.h>
 #include <Interpreters/Cluster.h>
 
 namespace DB

dbms/src/Interpreters/Context.h

@@ -2,14 +2,16 @@
 
 #include <Core/Block.h>
 #include <Core/NamesAndTypes.h>
+#include <Core/Settings.h>
 #include <Core/Types.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <Interpreters/ClientInfo.h>
-#include <Core/Settings.h>
 #include <Parsers/IAST_fwd.h>
 #include <Common/LRUCache.h>
 #include <Common/MultiVersion.h>
 #include <Common/ThreadPool.h>
 #include <Common/config.h>
+#include <Storages/IStorage_fwd.h>
 
 #include <atomic>
 #include <chrono>
@@ -65,14 +67,7 @@ struct MergeTreeSettings;
 class IDatabase;
 class DDLGuard;
 class DDLWorker;
-class IStorage;
 class ITableFunction;
-using StoragePtr = std::shared_ptr<IStorage>;
-using Tables = std::map<String, StoragePtr>;
-class IBlockInputStream;
-class IBlockOutputStream;
-using BlockInputStreamPtr = std::shared_ptr<IBlockInputStream>;
-using BlockOutputStreamPtr = std::shared_ptr<IBlockOutputStream>;
 class Block;
 class ActionLocksManager;
 using ActionLocksManagerPtr = std::shared_ptr<ActionLocksManager>;

dbms/src/Interpreters/ExecuteScalarSubqueriesVisitor.cpp

@@ -10,6 +10,7 @@
 #include <Interpreters/InterpreterSelectWithUnionQuery.h>
 #include <Interpreters/ExecuteScalarSubqueriesVisitor.h>
 
+#include <DataStreams/IBlockInputStream.h>
 #include <DataTypes/DataTypeAggregateFunction.h>
 
 namespace DB

dbms/src/Interpreters/ExpressionActions.h

 #pragma once
 
+#include <Core/Block.h>
+#include <Core/ColumnWithTypeAndName.h>
+#include <Core/Names.h>
+#include <Core/Settings.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <Interpreters/Context.h>
-#include <Common/config.h>
 #include <Common/SipHash.h>
-#include <Core/Settings.h>
-#include <Core/Names.h>
-#include <Core/ColumnWithTypeAndName.h>
-#include <Core/Block.h>
+#include <Common/config.h>
 
-#include <unordered_set>
 #include <unordered_map>
+#include <unordered_set>
 
 
 namespace DB
@@ -37,9 +38,6 @@ using FunctionBuilderPtr = std::shared_ptr<IFunctionBuilder>;
 class IDataType;
 using DataTypePtr = std::shared_ptr<const IDataType>;
 
-class IBlockInputStream;
-using BlockInputStreamPtr = std::shared_ptr<IBlockInputStream>;
-
 class ExpressionActions;
 
 /** Action on the block.

dbms/src/Interpreters/ExpressionAnalyzer.cpp

@@ -39,6 +39,7 @@
 #include <Storages/StorageJoin.h>
 
 #include <DataStreams/copyData.h>
+#include <DataStreams/IBlockInputStream.h>
 
 #include <Dictionaries/IDictionary.h>
 

dbms/src/Interpreters/ExpressionAnalyzer.h

 #pragma once
 
+#include <Core/Settings.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <Interpreters/ActionsVisitor.h>
 #include <Interpreters/AggregateDescription.h>
-#include <Core/Settings.h>
 #include <Interpreters/SyntaxAnalyzer.h>
 #include <Parsers/IAST_fwd.h>
+#include <Storages/IStorage_fwd.h>
 
 
 namespace DB
@@ -19,13 +21,6 @@ using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
 
 struct ASTTableJoin;
 
-class IBlockInputStream;
-using BlockInputStreamPtr = std::shared_ptr<IBlockInputStream>;
-
-class IStorage;
-using StoragePtr = std::shared_ptr<IStorage>;
-using Tables = std::map<String, StoragePtr>;
-
 class ASTFunction;
 class ASTExpressionList;
 class ASTSelectQuery;

dbms/src/Interpreters/InJoinSubqueriesPreprocessor.h

 #pragma once
 
-#include <string>
-#include <memory>
-#include <Core/Types.h>
 #include <Core/SettingsCommon.h>
+#include <Core/Types.h>
 #include <Parsers/IAST_fwd.h>
+#include <Storages/IStorage_fwd.h>
+
+#include <string>
+#include <memory>
 
 
 namespace DB
 {
 
-class IStorage;
 class ASTSelectQuery;
 class Context;
 

dbms/src/Interpreters/InterpreterCheckQuery.h

 #pragma once
 
+#include <Core/Block.h>
 #include <Interpreters/IInterpreter.h>
-#include <Parsers/IAST.h>
+#include <Parsers/IAST_fwd.h>
 
 namespace DB
 {

dbms/src/Interpreters/InterpreterCreateQuery.h

@@ -2,6 +2,7 @@
 
 #include <Interpreters/IInterpreter.h>
 #include <Storages/ColumnsDescription.h>
+#include <Storages/IStorage_fwd.h>
 #include <Storages/IndicesDescription.h>
 #include <Common/ThreadPool.h>
 
@@ -12,8 +13,6 @@ namespace DB
 class Context;
 class ASTCreateQuery;
 class ASTExpressionList;
-class IStorage;
-using StoragePtr = std::shared_ptr<IStorage>;
 
 
 /** Allows to create new table or database,

dbms/src/Interpreters/InterpreterKillQueryQuery.h

 #pragma once
 
+#include <Core/Block.h>
 #include <Interpreters/IInterpreter.h>
-#include <Parsers/IAST.h>
+#include <Parsers/IAST_fwd.h>
 
 
 namespace DB

dbms/src/Interpreters/InterpreterSelectQuery.h

@@ -4,13 +4,14 @@
 
 #include <Core/QueryProcessingStage.h>
 #include <Parsers/ASTSelectQuery.h>
-#include <DataStreams/IBlockInputStream.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/ExpressionActions.h>
 #include <Interpreters/ExpressionAnalyzer.h>
 #include <Interpreters/IInterpreter.h>
 #include <Interpreters/SelectQueryOptions.h>
 #include <Storages/SelectQueryInfo.h>
+#include <Storages/TableStructureLockHolder.h>
 
 
 namespace Poco { class Logger; }

dbms/src/Interpreters/InterpreterSystemQuery.h

@@ -2,16 +2,16 @@
 
 #include <Interpreters/IInterpreter.h>
 #include <Parsers/IAST_fwd.h>
+#include <Storages/IStorage_fwd.h>
 
 
+namespace Poco { class Logger; }
+
 namespace DB
 {
 
 class Context;
 class ASTSystemQuery;
-class IStorage;
-using StoragePtr = std::shared_ptr<IStorage>;
-
 
 class InterpreterSystemQuery : public IInterpreter
 {

dbms/src/Interpreters/Join.h

@@ -18,7 +18,7 @@
 #include <Columns/ColumnFixedString.h>
 
 #include <DataStreams/SizeLimits.h>
-#include <DataStreams/IBlockInputStream.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <variant>
 #include <common/constexpr_helpers.h>
 

dbms/src/Interpreters/MutationsInterpreter.h

 #pragma once
 
-#include <Interpreters/ExpressionAnalyzer.h>
+#include <DataStreams/IBlockInputStream.h>
 #include <Interpreters/ExpressionActions.h>
+#include <Interpreters/ExpressionAnalyzer.h>
 #include <Interpreters/InterpreterSelectQuery.h>
-#include <DataStreams/IBlockInputStream.h>
-#include <Storages/IStorage.h>
+#include <Storages/IStorage_fwd.h>
 #include <Storages/MutationCommands.h>
 
 

dbms/src/Interpreters/ProcessList.h

 #pragma once
 
-#include <map>
-#include <list>
-#include <memory>
-#include <mutex>
-#include <condition_variable>
-#include <unordered_map>
-#include <shared_mutex>
-#include <Poco/Condition.h>
+
 #include <Core/Defines.h>
+#include <DataStreams/BlockIO.h>
 #include <IO/Progress.h>
-#include <Common/Stopwatch.h>
-#include <Common/MemoryTracker.h>
+#include <Interpreters/CancellationCode.h>
+#include <Interpreters/ClientInfo.h>
+#include <Interpreters/QueryPriorities.h>
+#include <Storages/IStorage_fwd.h>
+#include <Poco/Condition.h>
 #include <Common/CurrentMetrics.h>
+#include <Common/CurrentThread.h>
+#include <Common/MemoryTracker.h>
 #include <Common/ProfileEvents.h>
+#include <Common/Stopwatch.h>
 #include <Common/Throttler.h>
-#include <Common/CurrentThread.h>
-#include <Interpreters/QueryPriorities.h>
-#include <Interpreters/ClientInfo.h>
-#include <Interpreters/CancellationCode.h>
-#include <DataStreams/BlockIO.h>
+
+#include <condition_variable>
+#include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+#include <unordered_map>
 
 
 namespace CurrentMetrics
@@ -30,9 +33,6 @@ namespace CurrentMetrics
 namespace DB
 {
 
-class IStorage;
-using StoragePtr = std::shared_ptr<IStorage>;
-using Tables = std::map<String, StoragePtr>;
 class Context;
 struct Settings;
 class IAST;

dbms/src/Interpreters/SyntaxAnalyzer.h

 #pragma once
 
-#include <Interpreters/AnalyzedJoin.h>
 #include <Interpreters/Aliases.h>
+#include <Interpreters/AnalyzedJoin.h>
 #include <Interpreters/SelectQueryOptions.h>
+#include <Storages/IStorage_fwd.h>
 
 namespace DB
 {
 
-class IStorage;
-using StoragePtr = std::shared_ptr<IStorage>;
-
 NameSet removeDuplicateColumns(NamesAndTypesList & columns);
 
 struct SyntaxAnalyzerResult

dbms/src/Storages/AlterCommands.h

@@ -3,6 +3,7 @@
 #include <optional>
 #include <Core/NamesAndTypes.h>
 #include <Storages/ColumnsDescription.h>
+#include <Storages/IStorage_fwd.h>
 #include <Storages/IndicesDescription.h>
 
 
@@ -89,7 +90,6 @@ struct AlterCommand
     bool isMutable() const;
 };
 
-class IStorage;
 class Context;
 
 class AlterCommands : public std::vector<AlterCommand>

dbms/src/Storages/IStorage.cpp

 #include <Storages/IStorage.h>
+
 #include <Storages/AlterCommands.h>
 
+#include <sparsehash/dense_hash_map>
+#include <sparsehash/dense_hash_set>
+
 
 namespace DB
 {
 
-void IStorage::alter(const AlterCommands & params, const String & database_name, const String & table_name, const Context & context, TableStructureWriteLockHolder & table_lock_holder)
+namespace ErrorCodes
+{
+    extern const int COLUMN_QUERIED_MORE_THAN_ONCE;
+    extern const int DUPLICATE_COLUMN;
+    extern const int EMPTY_LIST_OF_COLUMNS_PASSED;
+    extern const int EMPTY_LIST_OF_COLUMNS_QUERIED;
+    extern const int NO_SUCH_COLUMN_IN_TABLE;
+    extern const int NOT_FOUND_COLUMN_IN_BLOCK;
+    extern const int TYPE_MISMATCH;
+}
+
+IStorage::IStorage(ColumnsDescription columns_)
+{
+    setColumns(std::move(columns_));
+}
+
+const ColumnsDescription & IStorage::getColumns() const
+{
+    return columns;
+}
+
+void IStorage::setColumns(ColumnsDescription columns_)
+{
+    if (columns_.getOrdinary().empty())
+        throw Exception("Empty list of columns passed", ErrorCodes::EMPTY_LIST_OF_COLUMNS_PASSED);
+    columns = std::move(columns_);
+}
+
+const IndicesDescription & IStorage::getIndices() const
+{
+    return indices;
+}
+
+void IStorage::setIndices(IndicesDescription indices_)
+{
+    indices = std::move(indices_);
+}
+
+NameAndTypePair IStorage::getColumn(const String & column_name) const
+{
+    /// By default, we assume that there are no virtual columns in the storage.
+    return getColumns().getPhysical(column_name);
+}
+
+bool IStorage::hasColumn(const String & column_name) const
+{
+    /// By default, we assume that there are no virtual columns in the storage.
+    return getColumns().hasPhysical(column_name);
+}
+
+Block IStorage::getSampleBlock() const
+{
+    Block res;
+
+    for (const auto & column : getColumns().getAllPhysical())
+        res.insert({column.type->createColumn(), column.type, column.name});
+
+    return res;
+}
+
+Block IStorage::getSampleBlockNonMaterialized() const
+{
+    Block res;
+
+    for (const auto & column : getColumns().getOrdinary())
+        res.insert({column.type->createColumn(), column.type, column.name});
+
+    return res;
+}
+
+Block IStorage::getSampleBlockForColumns(const Names & column_names) const
+{
+    Block res;
+
+    NamesAndTypesList all_columns = getColumns().getAll();
+    std::unordered_map<String, DataTypePtr> columns_map;
+    for (const auto & elem : all_columns)
+        columns_map.emplace(elem.name, elem.type);
+
+    for (const auto & name : column_names)
+    {
+        auto it = columns_map.find(name);
+        if (it != columns_map.end())
+        {
+            res.insert({it->second->createColumn(), it->second, it->first});
+        }
+        else
+        {
+            /// Virtual columns.
+            NameAndTypePair elem = getColumn(name);
+            res.insert({elem.type->createColumn(), elem.type, elem.name});
+        }
+    }
+
+    return res;
+}
+
+namespace
+{
+    using NamesAndTypesMap = GOOGLE_NAMESPACE::dense_hash_map<StringRef, const IDataType *, StringRefHash>;
+    using UniqueStrings = GOOGLE_NAMESPACE::dense_hash_set<StringRef, StringRefHash>;
+
+    String listOfColumns(const NamesAndTypesList & available_columns)
+    {
+        std::stringstream ss;
+        for (auto it = available_columns.begin(); it != available_columns.end(); ++it)
+        {
+            if (it != available_columns.begin())
+                ss << ", ";
+            ss << it->name;
+        }
+        return ss.str();
+    }
+
+    NamesAndTypesMap getColumnsMap(const NamesAndTypesList & columns)
+    {
+        NamesAndTypesMap res;
+        res.set_empty_key(StringRef());
+
+        for (const auto & column : columns)
+            res.insert({column.name, column.type.get()});
+
+        return res;
+    }
+
+    UniqueStrings initUniqueStrings()
+    {
+        UniqueStrings strings;
+        strings.set_empty_key(StringRef());
+        return strings;
+    }
+}
+
+void IStorage::check(const Names & column_names) const
+{
+    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
+    const String list_of_columns = listOfColumns(available_columns);
+
+    if (column_names.empty())
+        throw Exception("Empty list of columns queried. There are columns: " + list_of_columns, ErrorCodes::EMPTY_LIST_OF_COLUMNS_QUERIED);
+
+    const auto columns_map = getColumnsMap(available_columns);
+
+    auto unique_names = initUniqueStrings();
+    for (const auto & name : column_names)
+    {
+        if (columns_map.end() == columns_map.find(name))
+            throw Exception(
+                "There is no column with name " + name + " in table. There are columns: " + list_of_columns,
+                ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
+
+        if (unique_names.end() != unique_names.find(name))
+            throw Exception("Column " + name + " queried more than once", ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE);
+        unique_names.insert(name);
+    }
+}
+
+void IStorage::check(const NamesAndTypesList & provided_columns) const
+{
+    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
+    const auto columns_map = getColumnsMap(available_columns);
+
+    auto unique_names = initUniqueStrings();
+    for (const NameAndTypePair & column : provided_columns)
+    {
+        auto it = columns_map.find(column.name);
+        if (columns_map.end() == it)
+            throw Exception(
+                "There is no column with name " + column.name + ". There are columns: " + listOfColumns(available_columns),
+                ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
+
+        if (!column.type->equals(*it->second))
+            throw Exception(
+                "Type mismatch for column " + column.name + ". Column has type " + it->second->getName() + ", got type "
+                    + column.type->getName(),
+                ErrorCodes::TYPE_MISMATCH);
+
+        if (unique_names.end() != unique_names.find(column.name))
+            throw Exception("Column " + column.name + " queried more than once", ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE);
+        unique_names.insert(column.name);
+    }
+}
+
+void IStorage::check(const NamesAndTypesList & provided_columns, const Names & column_names) const
+{
+    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
+    const auto available_columns_map = getColumnsMap(available_columns);
+    const auto & provided_columns_map = getColumnsMap(provided_columns);
+
+    if (column_names.empty())
+        throw Exception(
+            "Empty list of columns queried. There are columns: " + listOfColumns(available_columns),
+            ErrorCodes::EMPTY_LIST_OF_COLUMNS_QUERIED);
+
+    auto unique_names = initUniqueStrings();
+    for (const String & name : column_names)
+    {
+        auto it = provided_columns_map.find(name);
+        if (provided_columns_map.end() == it)
+            continue;
+
+        auto jt = available_columns_map.find(name);
+        if (available_columns_map.end() == jt)
+            throw Exception(
+                "There is no column with name " + name + ". There are columns: " + listOfColumns(available_columns),
+                ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
+
+        if (!it->second->equals(*jt->second))
+            throw Exception(
+                "Type mismatch for column " + name + ". Column has type " + jt->second->getName() + ", got type " + it->second->getName(),
+                ErrorCodes::TYPE_MISMATCH);
+
+        if (unique_names.end() != unique_names.find(name))
+            throw Exception("Column " + name + " queried more than once", ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE);
+        unique_names.insert(name);
+    }
+}
+
+void IStorage::check(const Block & block, bool need_all) const
+{
+    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
+    const auto columns_map = getColumnsMap(available_columns);
+
+    NameSet names_in_block;
+
+    block.checkNumberOfRows();
+
+    for (const auto & column : block)
+    {
+        if (names_in_block.count(column.name))
+            throw Exception("Duplicate column " + column.name + " in block", ErrorCodes::DUPLICATE_COLUMN);
+
+        names_in_block.insert(column.name);
+
+        auto it = columns_map.find(column.name);
+        if (columns_map.end() == it)
+            throw Exception(
+                "There is no column with name " + column.name + ". There are columns: " + listOfColumns(available_columns),
+                ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
+
+        if (!column.type->equals(*it->second))
+            throw Exception(
+                "Type mismatch for column " + column.name + ". Column has type " + it->second->getName() + ", got type "
+                    + column.type->getName(),
+                ErrorCodes::TYPE_MISMATCH);
+    }
+
+    if (need_all && names_in_block.size() < columns_map.size())
+    {
+        for (auto it = available_columns.begin(); it != available_columns.end(); ++it)
+        {
+            if (!names_in_block.count(it->name))
+                throw Exception("Expected column " + it->name, ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK);
+        }
+    }
+}
+
+void IStorage::alter(
+    const AlterCommands & params,
+    const String & database_name,
+    const String & table_name,
+    const Context & context,
+    TableStructureWriteLockHolder & table_lock_holder)
 {
     for (const auto & param : params)
     {
@@ -20,5 +286,4 @@ void IStorage::alter(const AlterCommands & params, const String & database_name,
     context.getDatabase(database_name)->alterTable(context, table_name, new_columns, new_indices, {});
     setColumns(std::move(new_columns));
 }
-
 }

dbms/src/Storages/IStorage.h

 #pragma once
 
-#include <Common/Exception.h>
-#include <Common/RWLock.h>
 #include <Core/Names.h>
 #include <Core/QueryProcessingStage.h>
+#include <DataStreams/IBlockStream_fwd.h>
 #include <Databases/IDatabase.h>
-#include <Storages/ITableDeclaration.h>
-#include <Storages/TableStructureLockHolder.h>
-#include <Storages/SelectQueryInfo.h>
 #include <Interpreters/CancellationCode.h>
-#include <shared_mutex>
-#include <memory>
-#include <optional>
+#include <Storages/IStorage_fwd.h>
+#include <Storages/SelectQueryInfo.h>
+#include <Storages/TableStructureLockHolder.h>
 #include <Common/ActionLock.h>
+#include <Common/Exception.h>
+#include <Common/RWLock.h>
+
+#include <optional>
+#include <shared_mutex>
 
 
 namespace DB
@@ -25,22 +26,11 @@ namespace ErrorCodes
 }
 
 class Context;
-class IBlockInputStream;
-class IBlockOutputStream;
 
 using StorageActionBlockType = size_t;
 
-using BlockOutputStreamPtr = std::shared_ptr<IBlockOutputStream>;
-using BlockInputStreamPtr = std::shared_ptr<IBlockInputStream>;
-using BlockInputStreams = std::vector<BlockInputStreamPtr>;
-
 class ASTCreateQuery;
 
-class IStorage;
-
-using StoragePtr = std::shared_ptr<IStorage>;
-using StorageWeakPtr = std::weak_ptr<IStorage>;
-
 struct Settings;
 
 class AlterCommands;
@@ -48,42 +38,85 @@ class MutationCommands;
 class PartitionCommands;
 
 
-/** Storage. Responsible for
+/** Storage. Describes the table. Responsible for
   * - storage of the table data;
   * - the definition in which files (or not in files) the data is stored;
   * - data lookups and appends;
   * - data storage structure (compression, etc.)
   * - concurrent access to data (locks, etc.)
   */
-class IStorage : public std::enable_shared_from_this<IStorage>, private boost::noncopyable, public ITableDeclaration
+class IStorage : public std::enable_shared_from_this<IStorage>
 {
 public:
+    IStorage() = default;
+    explicit IStorage(ColumnsDescription columns_);
+
+    virtual ~IStorage() = default;
+    IStorage(const IStorage &) = delete;
+    IStorage & operator=(const IStorage &) = delete;
+
     /// The main name of the table type (for example, StorageMergeTree).
     virtual std::string getName() const = 0;
 
     /// The name of the table.
     virtual std::string getTableName() const = 0;
-    virtual std::string getDatabaseName() const { return {}; }  // FIXME: should be abstract method.
+    virtual std::string getDatabaseName() const { return {}; }  // FIXME: should be an abstract method!
 
-    /** Returns true if the storage receives data from a remote server or servers. */
+    /// Returns true if the storage receives data from a remote server or servers.
     virtual bool isRemote() const { return false; }
 
-    /** Returns true if the storage supports queries with the SAMPLE section. */
+    /// Returns true if the storage supports queries with the SAMPLE section.
     virtual bool supportsSampling() const { return false; }
 
-    /** Returns true if the storage supports queries with the FINAL section. */
+    /// Returns true if the storage supports queries with the FINAL section.
     virtual bool supportsFinal() const { return false; }
 
-    /** Returns true if the storage supports queries with the PREWHERE section. */
+    /// Returns true if the storage supports queries with the PREWHERE section.
     virtual bool supportsPrewhere() const { return false; }
 
-    /** Returns true if the storage replicates SELECT, INSERT and ALTER commands among replicas. */
+    /// Returns true if the storage replicates SELECT, INSERT and ALTER commands among replicas.
     virtual bool supportsReplication() const { return false; }
 
-    /** Returns true if the storage supports deduplication of inserted data blocks . */
+    /// Returns true if the storage supports deduplication of inserted data blocks.
     virtual bool supportsDeduplication() const { return false; }
 
 
+public: /// thread-unsafe part
+    const ColumnsDescription & getColumns() const;
+    void setColumns(ColumnsDescription columns_);
+
+    const IndicesDescription & getIndices() const;
+    void setIndices(IndicesDescription indices_);
+
+    /// NOTE: these methods should include virtual columns,
+    ///       but should NOT include ALIAS columns (they are treated separately).
+    virtual NameAndTypePair getColumn(const String & column_name) const;
+    virtual bool hasColumn(const String & column_name) const;
+
+    Block getSampleBlock() const;
+    Block getSampleBlockNonMaterialized() const;
+    Block getSampleBlockForColumns(const Names & column_names) const; /// including virtual and alias columns.
+
+    /// Verify that all the requested names are in the table and are set correctly:
+    /// list of names is not empty and the names do not repeat.
+    void check(const Names & column_names) const;
+
+    /// Check that all the requested names are in the table and have the correct types.
+    void check(const NamesAndTypesList & columns) const;
+
+    /// Check that all names from the intersection of `names` and `columns` are in the table and have the same types.
+    void check(const NamesAndTypesList & columns, const Names & column_names) const;
+
+    /// Check that the data block contains all the columns of the table with the correct types,
+    /// contains only the columns of the table, and all the columns are different.
+    /// If |need_all| is set, then checks that all the columns of the table are in the block.
+    void check(const Block & block, bool need_all = false) const;
+
+private:
+    ColumnsDescription columns;
+    IndicesDescription indices;
+
+public:
     /// Acquire this lock if you need the table structure to remain constant during the execution of
     /// the query. If will_add_new_data is true, this means that the query will add new data to the table
     /// (INSERT or a parts merge).
@@ -335,9 +368,6 @@ public:
     /// Returns additional columns that need to be read for FINAL to work.
     virtual Names getColumnsRequiredForFinal() const { return {}; }
 
-    using ITableDeclaration::ITableDeclaration;
-    using std::enable_shared_from_this<IStorage>::shared_from_this;
-
 private:
     /// You always need to take the next three locks in this order.
 
@@ -357,7 +387,4 @@ private:
     mutable RWLock structure_lock = RWLockImpl::create();
 };
 
-/// table name -> table
-using Tables = std::map<String, StoragePtr>;
-
 }

dbms/src/Storages/IStorage_fwd.h

+#pragma once
+
+#include <Core/Types.h>
+
+#include <map>
+#include <memory>
+
+namespace DB
+{
+
+class IStorage;
+
+using StoragePtr = std::shared_ptr<IStorage>;
+using StorageWeakPtr = std::weak_ptr<IStorage>;
+using Tables = std::map<String, StoragePtr>;
+
+}

dbms/src/Storages/ITableDeclaration.cpp

-#include <Storages/ITableDeclaration.h>
-#include <Common/Exception.h>
-
-#include <boost/range/join.hpp>
-#include <sparsehash/dense_hash_map>
-#include <sparsehash/dense_hash_set>
-
-#include <unordered_set>
-#include <sstream>
-
-
-namespace DB
-{
-
-namespace ErrorCodes
-{
-    extern const int NO_SUCH_COLUMN_IN_TABLE;
-    extern const int EMPTY_LIST_OF_COLUMNS_QUERIED;
-    extern const int COLUMN_QUERIED_MORE_THAN_ONCE;
-    extern const int TYPE_MISMATCH;
-    extern const int DUPLICATE_COLUMN;
-    extern const int NOT_FOUND_COLUMN_IN_BLOCK;
-    extern const int EMPTY_LIST_OF_COLUMNS_PASSED;
-}
-
-const ColumnsDescription & ITableDeclaration::getColumns() const
-{
-    return columns;
-}
-
-const IndicesDescription & ITableDeclaration::getIndices() const
-{
-    return indices;
-}
-
-
-void ITableDeclaration::setColumns(ColumnsDescription columns_)
-{
-    if (columns_.getOrdinary().empty())
-        throw Exception("Empty list of columns passed", ErrorCodes::EMPTY_LIST_OF_COLUMNS_PASSED);
-    columns = std::move(columns_);
-}
-
-void ITableDeclaration::setIndices(IndicesDescription indices_)
-{
-    indices = std::move(indices_);
-}
-
-
-bool ITableDeclaration::hasColumn(const String & column_name) const
-{
-    return getColumns().hasPhysical(column_name); /// By default, we assume that there are no virtual columns in the storage.
-}
-
-NameAndTypePair ITableDeclaration::getColumn(const String & column_name) const
-{
-    return getColumns().getPhysical(column_name); /// By default, we assume that there are no virtual columns in the storage.
-}
-
-
-Block ITableDeclaration::getSampleBlock() const
-{
-    Block res;
-
-    for (const auto & col : getColumns().getAllPhysical())
-        res.insert({ col.type->createColumn(), col.type, col.name });
-
-    return res;
-}
-
-
-Block ITableDeclaration::getSampleBlockNonMaterialized() const
-{
-    Block res;
-
-    for (const auto & col : getColumns().getOrdinary())
-        res.insert({ col.type->createColumn(), col.type, col.name });
-
-    return res;
-}
-
-
-Block ITableDeclaration::getSampleBlockForColumns(const Names & column_names) const
-{
-    Block res;
-
-    NamesAndTypesList all_columns = getColumns().getAll();
-    std::unordered_map<String, DataTypePtr> columns_map;
-    for (const auto & elem : all_columns)
-        columns_map.emplace(elem.name, elem.type);
-
-    for (const auto & name : column_names)
-    {
-        auto it = columns_map.find(name);
-        if (it != columns_map.end())
-        {
-            res.insert({ it->second->createColumn(), it->second, it->first });
-        }
-        else
-        {
-            /// Virtual columns.
-            NameAndTypePair elem = getColumn(name);
-            res.insert({ elem.type->createColumn(), elem.type, elem.name });
-        }
-    }
-
-    return res;
-}
-
-
-static std::string listOfColumns(const NamesAndTypesList & available_columns)
-{
-    std::stringstream s;
-    for (auto it = available_columns.begin(); it != available_columns.end(); ++it)
-    {
-        if (it != available_columns.begin())
-            s << ", ";
-        s << it->name;
-    }
-    return s.str();
-}
-
-
-using NamesAndTypesMap = GOOGLE_NAMESPACE::dense_hash_map<StringRef, const IDataType *, StringRefHash>;
-
-static NamesAndTypesMap & getColumnsMapImpl(NamesAndTypesMap & res) { return res; }
-
-template <typename Arg, typename... Args>
-static NamesAndTypesMap & getColumnsMapImpl(NamesAndTypesMap & res, const Arg & arg, const Args &... args)
-{
-    static_assert(std::is_same_v<Arg, NamesAndTypesList>, "getColumnsMap requires arguments of type NamesAndTypesList");
-
-    for (const auto & column : arg)
-        res.insert({column.name, column.type.get()});
-
-    return getColumnsMapImpl(res, args...);
-}
-
-template <typename... Args>
-static NamesAndTypesMap getColumnsMap(const Args &... args)
-{
-    NamesAndTypesMap res;
-    res.set_empty_key(StringRef());
-
-    return getColumnsMapImpl(res, args...);
-}
-
-
-void ITableDeclaration::check(const Names & column_names) const
-{
-    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
-
-    if (column_names.empty())
-        throw Exception("Empty list of columns queried. There are columns: " + listOfColumns(available_columns),
-            ErrorCodes::EMPTY_LIST_OF_COLUMNS_QUERIED);
-
-    const auto columns_map = getColumnsMap(available_columns);
-
-    using UniqueStrings = GOOGLE_NAMESPACE::dense_hash_set<StringRef, StringRefHash>;
-    UniqueStrings unique_names;
-    unique_names.set_empty_key(StringRef());
-
-    for (const auto & name : column_names)
-    {
-        if (columns_map.end() == columns_map.find(name))
-            throw Exception("There is no column with name " + name + " in table. There are columns: " + listOfColumns(available_columns),
-                ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
-
-        if (unique_names.end() != unique_names.find(name))
-            throw Exception("Column " + name + " queried more than once",
-                ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE);
-        unique_names.insert(name);
-    }
-}
-
-
-void ITableDeclaration::check(const NamesAndTypesList & provided_columns) const
-{
-    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
-    const auto columns_map = getColumnsMap(available_columns);
-
-    using UniqueStrings = GOOGLE_NAMESPACE::dense_hash_set<StringRef, StringRefHash>;
-    UniqueStrings unique_names;
-    unique_names.set_empty_key(StringRef());
-
-    for (const NameAndTypePair & column : provided_columns)
-    {
-        NamesAndTypesMap::const_iterator it = columns_map.find(column.name);
-        if (columns_map.end() == it)
-            throw Exception("There is no column with name " + column.name + ". There are columns: "
-                + listOfColumns(available_columns), ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
-
-        if (!column.type->equals(*it->second))
-            throw Exception("Type mismatch for column " + column.name + ". Column has type "
-                + it->second->getName() + ", got type " + column.type->getName(), ErrorCodes::TYPE_MISMATCH);
-
-        if (unique_names.end() != unique_names.find(column.name))
-            throw Exception("Column " + column.name + " queried more than once",
-                ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE);
-        unique_names.insert(column.name);
-    }
-}
-
-
-void ITableDeclaration::check(const NamesAndTypesList & provided_columns, const Names & column_names) const
-{
-    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
-    const auto available_columns_map = getColumnsMap(available_columns);
-    const NamesAndTypesMap & provided_columns_map = getColumnsMap(provided_columns);
-
-    if (column_names.empty())
-        throw Exception("Empty list of columns queried. There are columns: " + listOfColumns(available_columns),
-            ErrorCodes::EMPTY_LIST_OF_COLUMNS_QUERIED);
-
-    using UniqueStrings = GOOGLE_NAMESPACE::dense_hash_set<StringRef, StringRefHash>;
-    UniqueStrings unique_names;
-    unique_names.set_empty_key(StringRef());
-
-    for (const String & name : column_names)
-    {
-        NamesAndTypesMap::const_iterator it = provided_columns_map.find(name);
-        if (provided_columns_map.end() == it)
-            continue;
-
-        NamesAndTypesMap::const_iterator jt = available_columns_map.find(name);
-        if (available_columns_map.end() == jt)
-            throw Exception("There is no column with name " + name + ". There are columns: "
-                + listOfColumns(available_columns), ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
-
-        if (!it->second->equals(*jt->second))
-            throw Exception("Type mismatch for column " + name + ". Column has type "
-                + jt->second->getName() + ", got type " + it->second->getName(), ErrorCodes::TYPE_MISMATCH);
-
-        if (unique_names.end() != unique_names.find(name))
-            throw Exception("Column " + name + " queried more than once",
-                ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE);
-        unique_names.insert(name);
-    }
-}
-
-
-void ITableDeclaration::check(const Block & block, bool need_all) const
-{
-    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
-    const auto columns_map = getColumnsMap(available_columns);
-
-    NameSet names_in_block;
-
-    block.checkNumberOfRows();
-
-    for (const auto & column : block)
-    {
-        if (names_in_block.count(column.name))
-            throw Exception("Duplicate column " + column.name + " in block",
-                            ErrorCodes::DUPLICATE_COLUMN);
-
-        names_in_block.insert(column.name);
-
-        NamesAndTypesMap::const_iterator it = columns_map.find(column.name);
-        if (columns_map.end() == it)
-            throw Exception("There is no column with name " + column.name + ". There are columns: "
-                + listOfColumns(available_columns), ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
-
-        if (!column.type->equals(*it->second))
-            throw Exception("Type mismatch for column " + column.name + ". Column has type "
-                + it->second->getName() + ", got type " + column.type->getName(), ErrorCodes::TYPE_MISMATCH);
-    }
-
-    if (need_all && names_in_block.size() < columns_map.size())
-    {
-        for (NamesAndTypesList::const_iterator it = available_columns.begin(); it != available_columns.end(); ++it)
-        {
-            if (!names_in_block.count(it->name))
-                throw Exception("Expected column " + it->name, ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK);
-        }
-    }
-}
-
-
-ITableDeclaration::ITableDeclaration(ColumnsDescription columns_)
-{
-    setColumns(std::move(columns_));
-}
-
-}

dbms/src/Storages/ITableDeclaration.h

-#pragma once
-
-#include <Storages/ColumnsDescription.h>
-#include <Storages/IndicesDescription.h>
-
-
-namespace DB
-{
-
-/** Description of the table.
-  * Is not thread safe. See IStorage::lockStructure ().
-  */
-class ITableDeclaration
-{
-public:
-    const ColumnsDescription & getColumns() const;
-    void setColumns(ColumnsDescription columns_);
-
-    const IndicesDescription & getIndices() const;
-    void setIndices(IndicesDescription indices_);
-
-    /// NOTE: These methods should include virtual columns, but should NOT include ALIAS columns
-    /// (they are treated separately).
-    virtual NameAndTypePair getColumn(const String & column_name) const;
-    virtual bool hasColumn(const String & column_name) const;
-
-    Block getSampleBlock() const;
-    Block getSampleBlockNonMaterialized() const;
-
-    /// Including virtual and alias columns.
-    Block getSampleBlockForColumns(const Names & column_names) const;
-
-    /** Verify that all the requested names are in the table and are set correctly.
-      * (the list of names is not empty and the names do not repeat)
-      */
-    void check(const Names & column_names) const;
-
-    /** Check that all the requested names are in the table and have the correct types.
-      */
-    void check(const NamesAndTypesList & columns) const;
-
-    /** Check that all names from the intersection of `names` and `columns` are in the table and have the same types.
-      */
-    void check(const NamesAndTypesList & columns, const Names & column_names) const;
-
-    /** Check that the data block contains all the columns of the table with the correct types,
-      *  contains only the columns of the table, and all the columns are different.
-      * If need_all, checks that all the columns of the table are in the block.
-      */
-    void check(const Block & block, bool need_all = false) const;
-
-
-    ITableDeclaration() = default;
-    explicit ITableDeclaration(ColumnsDescription columns_);
-    virtual ~ITableDeclaration() = default;
-
-private:
-    ColumnsDescription columns;
-    IndicesDescription indices;
-};
-
-}

dbms/src/Storages/MergeTree/DataPartsExchange.h

@@ -2,7 +2,7 @@
 
 #include <Interpreters/InterserverIOHandler.h>
 #include <Storages/MergeTree/MergeTreeData.h>
-#include <Storages/IStorage.h>
+#include <Storages/IStorage_fwd.h>
 #include <IO/HashingWriteBuffer.h>
 #include <IO/copyData.h>
 #include <IO/ConnectionTimeouts.h>

dbms/src/Storages/MutationCommands.h

 #pragma once
 
 #include <Parsers/ASTAlterQuery.h>
+#include <Storages/IStorage_fwd.h>
+
 #include <optional>
 #include <unordered_map>
 
@@ -8,7 +10,6 @@
 namespace DB
 {
 
-class IStorage;
 class Context;
 class WriteBuffer;
 class ReadBuffer;

dbms/src/Storages/PartitionCommands.h

 #pragma once
 
-#include <Core/Types.h>
 #include <Core/Field.h>
+#include <Core/Types.h>
 #include <Parsers/IAST.h>
-#include <vector>
+#include <Storages/IStorage_fwd.h>
+
 #include <optional>
+#include <vector>
 
 
 namespace DB
 {
 
-class IStorage;
 class ASTAlterCommand;
 
 struct PartitionCommand

dbms/src/Storages/StorageFactory.h

 #pragma once
 
 #include <Common/NamePrompter.h>
-#include <Storages/IStorage.h>
+#include <Parsers/IAST_fwd.h>
+#include <Storages/ColumnsDescription.h>
+#include <Storages/IStorage_fwd.h>
 #include <ext/singleton.h>
 #include <unordered_map>
 

dbms/src/Storages/StorageMaterializedView.cpp

@@ -11,6 +11,8 @@
 #include <Interpreters/InterpreterRenameQuery.h>
 #include <Interpreters/DatabaseAndTableWithAlias.h>
 #include <Interpreters/AddDefaultDatabaseVisitor.h>
+#include <DataStreams/IBlockInputStream.h>
+#include <DataStreams/IBlockOutputStream.h>
 
 #include <Storages/StorageFactory.h>
 

dbms/src/Storages/System/StorageSystemPartsBase.cpp

@@ -259,7 +259,7 @@ NameAndTypePair StorageSystemPartsBase::getColumn(const String & column_name) co
     if (column_name == "_state")
         return NameAndTypePair("_state", std::make_shared<DataTypeString>());
 
-    return ITableDeclaration::getColumn(column_name);
+    return IStorage::getColumn(column_name);
 }
 
 bool StorageSystemPartsBase::hasColumn(const String & column_name) const
@@ -267,7 +267,7 @@ bool StorageSystemPartsBase::hasColumn(const String & column_name) const
     if (column_name == "_state")
         return true;
 
-    return ITableDeclaration::hasColumn(column_name);
+    return IStorage::hasColumn(column_name);
 }
 
 StorageSystemPartsBase::StorageSystemPartsBase(std::string name_, NamesAndTypesList && columns_)

dbms/src/Storages/System/StorageSystemPartsColumns.h

 #pragma once
 
 #include <ext/shared_ptr_helper.h>
-#include <Storages/IStorage.h>
 #include <Storages/System/StorageSystemPartsBase.h>
 
 

dbms/src/TableFunctions/ITableFunction.h

 #pragma once
 
 #include <Parsers/IAST_fwd.h>
+#include <Storages/IStorage_fwd.h>
 
-#include <string>
 #include <memory>
+#include <string>
 
 
 namespace DB
 {
 
 class Context;
-class IStorage;
-using StoragePtr = std::shared_ptr<IStorage>;
-
 
 /** Interface for table functions.
   *