move databases from Context to DatabaseCatalog

dbms/programs/copier/ClusterCopier.cpp

@@ -2467,7 +2467,7 @@ void ClusterCopierApp::mainImpl()
     registerDisks();
 
     static const std::string default_database = "_local";
-    context->addDatabase(default_database, std::make_shared<DatabaseMemory>(default_database));
+    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database));
     context->setCurrentDatabase(default_database);
 
     /// Initialize query scope just in case.

dbms/programs/local/LocalServer.cpp

@@ -188,7 +188,7 @@ try
       *  if such tables will not be dropped, clickhouse-server will not be able to load them due to security reasons.
       */
     std::string default_database = config().getString("default_database", "_local");
-    context->addDatabase(default_database, std::make_shared<DatabaseMemory>(default_database));
+    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database));
     context->setCurrentDatabase(default_database);
     applyCmdOptions();
 
@@ -201,7 +201,7 @@ try
         loadMetadataSystem(*context);
         attachSystemTables();
         loadMetadata(*context);
-        context->getDatabaseCatalog().loadDatabases();
+        DatabaseCatalog::instance().loadDatabases();
         LOG_DEBUG(log, "Loaded metadata.");
     }
     else
@@ -250,12 +250,12 @@ std::string LocalServer::getInitialCreateTableQuery()
 
 void LocalServer::attachSystemTables()
 {
-    DatabasePtr system_database = context->tryGetDatabase("system");
+    DatabasePtr system_database = DatabaseCatalog::instance().tryGetDatabase(DatabaseCatalog::SYSTEM_DATABASE);
     if (!system_database)
     {
         /// TODO: add attachTableDelayed into DatabaseMemory to speedup loading
-        system_database = std::make_shared<DatabaseMemory>("system");
-        context->addDatabase("system", system_database);
+        system_database = std::make_shared<DatabaseMemory>(DatabaseCatalog::SYSTEM_DATABASE);
+        DatabaseCatalog::instance().attachDatabase(DatabaseCatalog::SYSTEM_DATABASE, system_database);
     }
 
     attachSystemTablesLocal(*system_database);

dbms/programs/server/ReplicasStatusHandler.cpp

@@ -35,7 +35,7 @@ void ReplicasStatusHandler::handleRequest(Poco::Net::HTTPServerRequest & request
         bool ok = true;
         std::stringstream message;
 
-        auto databases = context.getDatabases();
+        auto databases = DatabaseCatalog::instance().getDatabases();
 
         /// Iterate through all the replicated tables.
         for (const auto & db : databases)

dbms/programs/server/Server.cpp

@@ -549,10 +549,10 @@ int Server::main(const std::vector<std::string> & /*args*/)
         /// After attaching system databases we can initialize system log.
         global_context->initializeSystemLogs();
         /// After the system database is created, attach virtual system tables (in addition to query_log and part_log)
-        attachSystemTablesServer(*global_context->getDatabase("system"), has_zookeeper);
+        attachSystemTablesServer(*DatabaseCatalog::instance().getSystemDatabase(), has_zookeeper);
         /// Then, load remaining databases
         loadMetadata(*global_context);
-        global_context->getDatabaseCatalog().loadDatabases();
+        DatabaseCatalog::instance().loadDatabases();
     }
     catch (...)
     {
@@ -693,7 +693,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
 
         /// This object will periodically calculate some metrics.
         AsynchronousMetrics async_metrics(*global_context);
-        attachSystemTablesAsync(*global_context->getDatabase("system"), async_metrics);
+        attachSystemTablesAsync(*DatabaseCatalog::instance().getSystemDatabase(), async_metrics);
 
         for (const auto & listen_host : listen_hosts)
         {

dbms/programs/server/TCPHandler.cpp

@@ -108,7 +108,7 @@ void TCPHandler::runImpl()
     /// When connecting, the default database can be specified.
     if (!default_database.empty())
     {
-        if (!connection_context.isDatabaseExist(default_database))
+        if (!DatabaseCatalog::instance().isDatabaseExist(default_database))
         {
             Exception e("Database " + backQuote(default_database) + " doesn't exist", ErrorCodes::UNKNOWN_DATABASE);
             LOG_ERROR(log, "Code: " << e.code() << ", e.displayText() = " << e.displayText()

dbms/src/Interpreters/ActionLocksManager.cpp

@@ -22,7 +22,7 @@ namespace ActionLocks
 template <typename F>
 inline void forEachTable(Context & context, F && f)
 {
-    for (auto & elem : context.getDatabases())
+    for (auto & elem : DatabaseCatalog::instance().getDatabases())
         for (auto iterator = elem.second->getTablesIterator(context); iterator->isValid(); iterator->next())
             f(iterator->table());
 

dbms/src/Interpreters/AsynchronousMetrics.cpp

 #include <Interpreters/AsynchronousMetrics.h>
 #include <Interpreters/ExpressionJIT.h>
+#include <Interpreters/DatabaseCatalog.h>
 #include <Common/Exception.h>
 #include <Common/setThreadName.h>
 #include <Common/CurrentMetrics.h>
@@ -131,7 +132,7 @@ void AsynchronousMetrics::update()
     set("Uptime", context.getUptimeSeconds());
 
     {
-        auto databases = context.getDatabases();
+        auto databases = DatabaseCatalog::instance().getDatabases();
 
         size_t max_queue_size = 0;
         size_t max_inserts_in_queue = 0;

dbms/src/Interpreters/Context.cpp

@@ -185,8 +185,6 @@ struct ContextShared
     String tmp_path;                                        /// Path to the temporary files that occur when processing the request.
     mutable VolumePtr tmp_volume;                           /// Volume for the the temporary files that occur when processing the request.
 
-    std::shared_ptr<DatabaseCatalog> database_catalog;      /// Manages databases and tables in them.
-
     mutable std::optional<EmbeddedDictionaries> embedded_dictionaries;    /// Metrica's dictionaries. Have lazy initialization.
     mutable std::optional<ExternalDictionariesLoader> external_dictionaries_loader;
     mutable std::optional<ExternalModelsLoader> external_models_loader;
@@ -317,7 +315,7 @@ struct ContextShared
         if (system_logs)
             system_logs->shutdown();
 
-        database_catalog->shutdown();
+        DatabaseCatalog::instance().shutdown();
 
         /// Preemptive destruction is important, because these objects may have a refcount to ContextShared (cyclic reference).
         /// TODO: Get rid of this.
@@ -362,7 +360,6 @@ Context Context::createGlobal()
     res.row_policy = std::make_shared<RowPolicyContext>();
     res.access_rights = std::make_shared<AccessRightsContext>();
     res.shared = std::make_shared<ContextShared>();
-    res.shared->database_catalog = std::make_shared<DatabaseCatalog>(res);
     return res;
 }
 
@@ -491,16 +488,6 @@ std::chrono::steady_clock::duration Context::closeSessions() const
     return shared->close_interval;
 }
 
-DatabaseCatalog & Context::getDatabaseCatalog() const
-{
-    return *shared->database_catalog;
-}
-
-Databases Context::getDatabases() const
-{
-    return shared->database_catalog->getDatabases();
-}
-
 String Context::resolveDatabase(const String & database_name) const
 {
     String res = database_name.empty() ? getCurrentDatabase() : database_name;
@@ -509,50 +496,6 @@ String Context::resolveDatabase(const String & database_name) const
     return res;
 }
 
-String Context::resolveDatabaseAndCheckAccess(const String & database_name) const
-{
-    auto lock = getLock();
-    String res = database_name.empty() ? current_database : database_name;
-    if (res.empty())
-        throw Exception("Default database is not selected", ErrorCodes::UNKNOWN_DATABASE);
-    return res;
-}
-
-//StorageID Context::resolveDatabase(StorageID table_id) const
-//{
-//    table_id.database_name = resolveDatabase(table_id.database_name);
-//    return table_id;
-//}
-
-DatabasePtr Context::getDatabase(const String & database_name) const
-{
-    auto db = resolveDatabaseAndCheckAccess(database_name);
-    return shared->database_catalog->getDatabase(db, *this);
-}
-
-DatabasePtr Context::tryGetDatabase(const String & database_name) const
-{
-    String db = resolveDatabase(database_name);
-    return shared->database_catalog->tryGetDatabase(database_name, *this);
-}
-
-bool Context::isDatabaseExist(const String & database_name) const
-{
-    String db = resolveDatabaseAndCheckAccess(database_name);
-    return shared->database_catalog->isDatabaseExist(database_name);
-}
-
-void Context::addDatabase(const String & database_name, const DatabasePtr & database)
-{
-    shared->database_catalog->attachDatabase(database_name, database, *this);
-}
-
-
-DatabasePtr Context::detachDatabase(const String & database_name)
-{
-    return shared->database_catalog->detachDatabase(database_name, *this);
-}
-
 String Context::getPath() const
 {
     auto lock = getLock();
@@ -833,14 +776,14 @@ bool Context::isTableExist(const String & database_name, const String & table_na
 {
     //FIXME do we need resolve temporary tables here?
     auto table_id = resolveStorageID({database_name, table_name});
-    return shared->database_catalog->isTableExist(table_id, *this);
+    return DatabaseCatalog::instance().isTableExist(table_id, *this);
 }
 
 bool Context::isDictionaryExists(const String & database_name, const String & dictionary_name) const
 {
     auto lock = getLock();
-    String db = resolveDatabaseAndCheckAccess(database_name);
-    auto db_ptr = shared->database_catalog->tryGetDatabase(database_name, *this);
+    String db = resolveDatabase(database_name);
+    auto db_ptr = DatabaseCatalog::instance().tryGetDatabase(database_name);
     return db_ptr && db_ptr->isDictionaryExist(*this, dictionary_name);
 }
 
@@ -849,21 +792,6 @@ bool Context::isExternalTableExist(const String & table_name) const
     return external_tables_mapping.count(table_name);
 }
 
-
-void Context::assertTableDoesntExist(const String & database_name, const String & table_name) const
-{
-    //FIXME do we need resolve temporary tables here? (and do we need this method?)
-    auto table_id = resolveStorageID({database_name, table_name});
-    shared->database_catalog->assertTableDoesntExist(table_id, *this);
-}
-
-
-void Context::assertDatabaseExists(const String & database_name) const
-{
-    String db = resolveDatabaseAndCheckAccess(database_name);
-    shared->database_catalog->assertDatabaseExists(db);
-}
-
 const Scalars & Context::getScalars() const
 {
     return scalars;
@@ -938,7 +866,7 @@ StoragePtr Context::tryGetTable(const StorageID & table_id) const
 StoragePtr Context::getTableImpl(const StorageID & table_id, std::optional<Exception> * exception) const
 {
     auto resolved_id = resolveStorageID(table_id);
-    return shared->database_catalog->getTable(resolved_id, *this, exception);
+    return DatabaseCatalog::instance().getTable(resolved_id, *this, exception);
 }
 
 
@@ -948,7 +876,7 @@ void Context::addExternalTable(const String & table_name, const StoragePtr & sto
     if (external_tables_mapping.end() != external_tables_mapping.find(table_name))
         throw Exception("Temporary table " + backQuoteIfNeed(table_name) + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS);
 
-    auto holder = std::make_shared<TemporaryTableHolder>(*this, *shared->database_catalog->getDatabaseForTemporaryTables(), storage, ast);
+    auto holder = std::make_shared<TemporaryTableHolder>(*this, *DatabaseCatalog::instance().getDatabaseForTemporaryTables(), storage, ast);
     external_tables_mapping.emplace(table_name, std::move(holder));
 }
 
@@ -1038,7 +966,7 @@ ASTPtr Context::getCreateExternalTableQuery(const String & table_name) const
     if (external_tables_mapping.end() == it)
         throw Exception("Temporary table " + backQuoteIfNeed(table_name) + " doesn't exist", ErrorCodes::UNKNOWN_TABLE);
 
-    return shared->database_catalog->getDatabaseForTemporaryTables()->getCreateTableQuery(*this, it->second->getGlobalTableID().table_name);
+    return DatabaseCatalog::instance().getDatabaseForTemporaryTables()->getCreateTableQuery(*this, it->second->getGlobalTableID().table_name);
 }
 
 Settings Context::getSettings() const
@@ -1140,10 +1068,10 @@ String Context::getInitialQueryId() const
 
 void Context::setCurrentDatabase(const String & name)
 {
+    DatabaseCatalog::instance().assertDatabaseExists(name);
     auto lock = getLock();
-    assertDatabaseExists(name);
-    current_database = name;
     calculateAccessRights();
+    current_database = name;
 }
 
 

dbms/src/Interpreters/Context.h

@@ -7,6 +7,7 @@
 #include <Core/UUID.h>
 #include <DataStreams/IBlockStream_fwd.h>
 #include <Interpreters/ClientInfo.h>
+#include <Interpreters/DatabaseCatalog.h>
 #include <Parsers/IAST_fwd.h>
 #include <Common/LRUCache.h>
 #include <Common/MultiVersion.h>
@@ -181,8 +182,6 @@ private:
 
     String default_format;  /// Format, used when server formats data by itself and if query does not have FORMAT specification.
                             /// Thus, used in HTTP interface. If not specified - then some globally default format is used.
-    // TODO maybe replace with DatabaseMemory?
-    //TableAndCreateASTs external_tables;     /// Temporary tables.
     using TemporaryTablesMapping = std::map<String, std::shared_ptr<TemporaryTableHolder>>;
     TemporaryTablesMapping external_tables_mapping;
     Scalars scalars;
@@ -302,15 +301,10 @@ public:
     void addDependencyUnsafe(const StorageID & from, const StorageID & where);
     void removeDependencyUnsafe(const StorageID & from, const StorageID & where);
 
-    DatabaseCatalog & getDatabaseCatalog() const;
-
     /// Checking the existence of the table/database. Database can be empty - in this case the current database is used.
     bool isTableExist(const String & database_name, const String & table_name) const;
-    bool isDatabaseExist(const String & database_name) const;
     bool isDictionaryExists(const String & database_name, const String & dictionary_name) const;
     bool isExternalTableExist(const String & table_name) const;
-    void assertTableDoesntExist(const String & database_name, const String & table_name) const;
-    void assertDatabaseExists(const String & database_name) const;
 
     String resolveDatabase(const String & database_name) const;
     String resolveDatabaseAndCheckAccess(const String & database_name) const;
@@ -336,9 +330,6 @@ public:
     void addViewSource(const StoragePtr & storage);
     StoragePtr getViewSource();
 
-    void addDatabase(const String & database_name, const DatabasePtr & database);
-    DatabasePtr detachDatabase(const String & database_name);
-
     /// Get an object that protects the table from concurrently executing multiple DDL operations.
     std::unique_ptr<DDLGuard> getDDLGuard(const String & database, const String & table) const;
 
@@ -418,11 +409,6 @@ public:
     /// Get query for the CREATE table.
     ASTPtr getCreateExternalTableQuery(const String & table_name) const;
 
-    DatabasePtr getDatabase(const String & database_name) const;
-    DatabasePtr tryGetDatabase(const String & database_name) const;
-
-    Databases getDatabases() const;
-
     std::shared_ptr<Context> acquireSession(const String & session_id, std::chrono::steady_clock::duration timeout, bool session_check) const;
     void releaseSession(const String & session_id, std::chrono::steady_clock::duration timeout);
 

dbms/src/Interpreters/DatabaseCatalog.cpp

@@ -17,11 +17,12 @@ namespace ErrorCodes
     extern const int DATABASE_ALREADY_EXISTS;
 }
 
+
 void DatabaseCatalog::loadDatabases()
 {
 
     auto db_for_temporary_and_external_tables = std::make_shared<DatabaseMemory>(TEMPORARY_DATABASE);
-    attachDatabase(TEMPORARY_DATABASE, db_for_temporary_and_external_tables, global_context);
+    attachDatabase(TEMPORARY_DATABASE, db_for_temporary_and_external_tables);
 }
 
 void DatabaseCatalog::shutdown()
@@ -131,7 +132,7 @@ void DatabaseCatalog::assertDatabaseDoesntExistUnlocked(const String & database_
         throw Exception("Database " + backQuoteIfNeed(database_name) + " already exists.", ErrorCodes::DATABASE_ALREADY_EXISTS);
 }
 
-void DatabaseCatalog::attachDatabase(const String & database_name, const DatabasePtr & database, const Context & /*local_context*/)
+void DatabaseCatalog::attachDatabase(const String & database_name, const DatabasePtr & database)
 {
     //local_context.checkDatabaseAccessRights(database_name);
     std::lock_guard lock{databases_mutex};
@@ -140,17 +141,18 @@ void DatabaseCatalog::attachDatabase(const String & database_name, const Databas
 }
 
 
-DatabasePtr DatabaseCatalog::detachDatabase(const String & database_name, const Context & local_context)
+DatabasePtr DatabaseCatalog::detachDatabase(const String & database_name)
 {
     //local_context.checkDatabaseAccessRights(database_name);
     std::lock_guard lock{databases_mutex};
-    auto res = getDatabase(database_name, local_context);   //FIXME locks order
+    auto res = getDatabase(database_name);   //FIXME locks order
     databases.erase(database_name);
     return res;
 }
 
-DatabasePtr DatabaseCatalog::getDatabase(const String & database_name, const Context & /*local_context*/) const
+DatabasePtr DatabaseCatalog::getDatabase(const String & database_name) const
 {
+    assert(!database_name.empty());
     //String db = local_context.resolveDatabase(database_name);
     //local_context.checkDatabaseAccessRights(db);    //FIXME non-atomic
     std::lock_guard lock{databases_mutex};
@@ -158,8 +160,9 @@ DatabasePtr DatabaseCatalog::getDatabase(const String & database_name, const Con
     return databases.find(database_name)->second;
 }
 
-DatabasePtr DatabaseCatalog::tryGetDatabase(const String & database_name, const Context & /*local_context*/) const
+DatabasePtr DatabaseCatalog::tryGetDatabase(const String & database_name) const
 {
+    assert(!database_name.empty());
     //String db = local_context.resolveDatabase(database_name);
     std::lock_guard lock{databases_mutex};
     auto it = databases.find(database_name);
@@ -170,6 +173,7 @@ DatabasePtr DatabaseCatalog::tryGetDatabase(const String & database_name, const
 
 bool DatabaseCatalog::isDatabaseExist(const String & database_name) const
 {
+    assert(!database_name.empty());
     std::lock_guard lock{databases_mutex};
     return databases.end() != databases.find(database_name);
 }
@@ -201,7 +205,12 @@ void DatabaseCatalog::assertTableDoesntExist(const StorageID & table_id, const C
 
 DatabasePtr DatabaseCatalog::getDatabaseForTemporaryTables() const
 {
-    return getDatabase(TEMPORARY_DATABASE, global_context);
+    return getDatabase(TEMPORARY_DATABASE);
+}
+
+DatabasePtr DatabaseCatalog::getSystemDatabase() const
+{
+    return getDatabase(SYSTEM_DATABASE);
 }
 
 void DatabaseCatalog::addUUIDMapping(const UUID & uuid, DatabasePtr database, StoragePtr table)
@@ -223,6 +232,18 @@ void DatabaseCatalog::removeUUIDMapping(const UUID & uuid)
         throw Exception("Mapping for table with UUID=" + toString(uuid) + " doesn't exist", ErrorCodes::LOGICAL_ERROR);
 }
 
+DatabaseCatalog & DatabaseCatalog::instance()
+{
+    static DatabaseCatalog database_catalog;
+    return database_catalog;
+}
+
+DatabasePtr DatabaseCatalog::getDatabase(const String & database_name, const Context & local_context) const
+{
+    String resolved_database = local_context.resolveDatabase(database_name);
+    return getDatabase(resolved_database);
+}
+
 }
 
 

dbms/src/Interpreters/DatabaseCatalog.h

@@ -27,9 +27,10 @@ public:
     static constexpr const char * TEMPORARY_DATABASE = "_temporary_and_external_tables";
     static constexpr const char * SYSTEM_DATABASE = "system";
 
+    static DatabaseCatalog & instance();
 
-    DatabaseCatalog(Context & global_context_/*, String default_database_*/)
-    : global_context(global_context_)/*, default_database(std::move(default_database_))*/ {}
+    //DatabaseCatalog(/*Context & global_context_, String default_database_*/) {}
+    //: global_context(global_context_)/*, default_database(std::move(default_database_))*/ {}
 
     void loadDatabases();
     void shutdown();
@@ -40,12 +41,14 @@ public:
     void assertDatabaseDoesntExist(const String & database_name) const;
 
     DatabasePtr getDatabaseForTemporaryTables() const;
+    DatabasePtr getSystemDatabase() const;
 
-    void attachDatabase(const String & database_name, const DatabasePtr & database, const Context & local_context);     // ca, a
-    DatabasePtr detachDatabase(const String & database_name, const Context & local_context);                            // (sr), ca, a
+    void attachDatabase(const String & database_name, const DatabasePtr & database);     // ca, a
+    DatabasePtr detachDatabase(const String & database_name);                            // (sr), ca, a
 
-    DatabasePtr getDatabase(const String & database_name, const Context & local_context) const;                         // sr, ca, a
-    DatabasePtr tryGetDatabase(const String & database_name, const Context & local_context) const;                      // sr
+    DatabasePtr getDatabase(const String & database_name, const Context & local_context) const;
+    DatabasePtr getDatabase(const String & database_name) const;                         // sr, ca, a
+    DatabasePtr tryGetDatabase(const String & database_name) const;                      // sr
     bool isDatabaseExist(const String & database_name) const;                                                           // sr, ca
     Databases getDatabases() const;
 
@@ -60,6 +63,7 @@ public:
     StoragePtr getTable(const StorageID & table_id, const Context & local_context, std::optional<Exception> * exception) const;
 
 private:
+    DatabaseCatalog() = default;
     void assertDatabaseExistsUnlocked(const String & database_name) const;
     void assertDatabaseDoesntExistUnlocked(const String & database_name) const;
 
@@ -78,7 +82,7 @@ private:
     }
 
 private:
-    [[maybe_unused]] Context & global_context;
+    //[[maybe_unused]] Context & global_context;
     mutable std::mutex databases_mutex;
     //const String default_database;
     Databases databases;

dbms/src/Interpreters/InterpreterCreateQuery.cpp

@@ -86,7 +86,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
     auto guard = context.getDDLGuard(database_name, "");
 
     /// Database can be created before or it can be created concurrently in another thread, while we were waiting in DDLGuard
-    if (context.isDatabaseExist(database_name))
+    if (DatabaseCatalog::instance().isDatabaseExist(database_name))
     {
         if (create.if_not_exists)
             return {};
@@ -147,7 +147,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
     bool renamed = false;
     try
     {
-        context.addDatabase(database_name, database);
+        DatabaseCatalog::instance().attachDatabase(database_name, database);
         added = true;
 
         if (need_write_metadata)
@@ -163,7 +163,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
         if (renamed)
             Poco::File(metadata_file_tmp_path).remove();
         if (added)
-            context.detachDatabase(database_name);
+            DatabaseCatalog::instance().detachDatabase(database_name);
 
         throw;
     }
@@ -507,10 +507,10 @@ void InterpreterCreateQuery::setEngine(ASTCreateQuery & create) const
     {
         /// NOTE Getting the structure from the table specified in the AS is done not atomically with the creation of the table.
 
-        String as_database_name = create.as_database.empty() ? context.getCurrentDatabase() : create.as_database;
+        String as_database_name = context.resolveDatabase(create.as_database);
         String as_table_name = create.as_table;
 
-        ASTPtr as_create_ptr = context.getDatabase(as_database_name)->getCreateTableQuery(context, as_table_name);
+        ASTPtr as_create_ptr = DatabaseCatalog::instance().getDatabase(as_database_name)->getCreateTableQuery(context, as_table_name);
         const auto & as_create = as_create_ptr->as<ASTCreateQuery &>();
 
         const String qualified_name = backQuoteIfNeed(as_database_name) + "." + backQuoteIfNeed(as_table_name);
@@ -542,18 +542,20 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
         throw Exception("Temporary tables cannot be inside a database. You should not specify a database for a temporary table.",
             ErrorCodes::BAD_DATABASE_FOR_TEMPORARY_TABLE);
 
+    String current_database = context.getCurrentDatabase();
+
     // If this is a stub ATTACH query, read the query definition from the database
     if (create.attach && !create.storage && !create.columns_list)
     {
         bool if_not_exists = create.if_not_exists;
         // Table SQL definition is available even if the table is detached
-        auto query = context.getDatabase(create.database)->getCreateTableQuery(context, create.table);
+        auto database_name = create.database.empty() ? current_database : create.database;
+        auto query = DatabaseCatalog::instance().getDatabase(database_name)->getCreateTableQuery(context, create.table);
         create = query->as<ASTCreateQuery &>(); // Copy the saved create query, but use ATTACH instead of CREATE
         create.attach = true;
         create.if_not_exists = if_not_exists;
     }
 
-    String current_database = context.getCurrentDatabase();
     if (!create.temporary && create.database.empty())
         create.database = current_database;
     if (!create.to_table.empty() && create.to_database.empty())
@@ -588,7 +590,7 @@ bool InterpreterCreateQuery::doCreateTable(const ASTCreateQuery & create,
     bool need_add_to_database = !create.temporary || create.is_live_view;
     if (need_add_to_database)
     {
-        database = context.getDatabase(create.database);
+        database = DatabaseCatalog::instance().getDatabase(create.database);
 
         /** If the request specifies IF NOT EXISTS, we allow concurrent CREATE queries (which do nothing).
           * If table doesnt exist, one thread is creating table, while others wait in DDLGuard.
@@ -684,12 +686,11 @@ BlockIO InterpreterCreateQuery::createDictionary(ASTCreateQuery & create)
 {
     String dictionary_name = create.table;
 
-    if (create.database.empty())
-        create.database = context.getCurrentDatabase();
+    create.database = context.resolveDatabase(create.database);
     const String & database_name = create.database;
 
     auto guard = context.getDDLGuard(database_name, dictionary_name);
-    DatabasePtr database = context.getDatabase(database_name);
+    DatabasePtr database = DatabaseCatalog::instance().getDatabase(database_name);
 
     if (database->isDictionaryExist(context, dictionary_name))
     {
@@ -703,7 +704,7 @@ BlockIO InterpreterCreateQuery::createDictionary(ASTCreateQuery & create)
 
     if (create.attach)
     {
-        auto query = context.getDatabase(database_name)->getCreateDictionaryQuery(context, dictionary_name);
+        auto query = DatabaseCatalog::instance().getDatabase(database_name)->getCreateDictionaryQuery(context, dictionary_name);
         create = query->as<ASTCreateQuery &>();
         create.attach = true;
     }

dbms/src/Interpreters/InterpreterDropQuery.cpp

@@ -76,7 +76,7 @@ BlockIO InterpreterDropQuery::executeToTable(
                         ErrorCodes::UNKNOWN_TABLE);
     }
 
-    String database_name = database_name_.empty() ? context.getCurrentDatabase() : database_name_;
+    String database_name = context.resolveDatabase(database_name_);
 
     auto ddl_guard = (!no_ddl_lock ? context.getDDLGuard(database_name, table_name) : nullptr);
 
@@ -168,7 +168,7 @@ BlockIO InterpreterDropQuery::executeToDictionary(
     if (is_temporary)
         throw Exception("Temporary dictionaries are not possible.", ErrorCodes::SYNTAX_ERROR);
 
-    String database_name = database_name_.empty() ? context.getCurrentDatabase() : database_name_;
+    String database_name = context.resolveDatabase(database_name_);
 
     auto ddl_guard = (!no_ddl_lock ? context.getDDLGuard(database_name, dictionary_name) : nullptr);
 
@@ -248,7 +248,7 @@ BlockIO InterpreterDropQuery::executeToDatabase(const String & database_name, AS
         else if (kind == ASTDropQuery::Kind::Detach)
         {
             context.checkAccess(AccessType::DETACH_DATABASE, database_name);
-            context.detachDatabase(database_name);
+            DatabaseCatalog::instance().detachDatabase(database_name);
             database->shutdown();
         }
         else if (kind == ASTDropQuery::Kind::Drop)
@@ -270,14 +270,14 @@ BlockIO InterpreterDropQuery::executeToDatabase(const String & database_name, AS
             auto context_lock = context.getLock();
 
             /// Someone could have time to delete the database before us.
-            context.assertDatabaseExists(database_name);
+            DatabaseCatalog::instance().assertDatabaseExists(database_name);
 
             /// Someone could have time to create a table in the database to be deleted while we deleted the tables without the context lock.
-            if (!context.getDatabase(database_name)->empty(context))
+            if (!DatabaseCatalog::instance().getDatabase(database_name)->empty(context))
                 throw Exception("New table appeared in database being dropped. Try dropping it again.", ErrorCodes::DATABASE_NOT_EMPTY);
 
             /// Delete database information from the RAM
-            context.detachDatabase(database_name);
+            DatabaseCatalog::instance().detachDatabase(database_name);
 
             database->shutdown();
 
@@ -296,7 +296,7 @@ BlockIO InterpreterDropQuery::executeToDatabase(const String & database_name, AS
 
 DatabasePtr InterpreterDropQuery::tryGetDatabase(const String & database_name, bool if_exists)
 {
-    return if_exists ? context.tryGetDatabase(database_name) : context.getDatabase(database_name);
+    return if_exists ? DatabaseCatalog::instance().tryGetDatabase(database_name) : DatabaseCatalog::instance().getDatabase(database_name);
 }
 
 DatabaseAndTable InterpreterDropQuery::tryGetDatabaseAndTable(const String & database_name, const String & table_name, bool if_exists)

dbms/src/Interpreters/InterpreterRenameQuery.cpp

@@ -88,16 +88,17 @@ BlockIO InterpreterRenameQuery::execute()
     for (auto & table_guard : table_guards)
         table_guard.second = context.getDDLGuard(table_guard.first.database_name, table_guard.first.table_name);
 
+    auto & database_catalog = DatabaseCatalog::instance();
     for (auto & elem : descriptions)
     {
-        context.assertTableDoesntExist(elem.to_database_name, elem.to_table_name);
+        database_catalog.assertTableDoesntExist(StorageID(elem.to_database_name, elem.to_table_name), context);
         auto from_table = context.getTable(elem.from_database_name, elem.from_table_name);
         auto from_table_lock = from_table->lockExclusively(context.getCurrentQueryId());
 
-        context.getDatabase(elem.from_database_name)->renameTable(
+        database_catalog.getDatabase(elem.from_database_name)->renameTable(
             context,
             elem.from_table_name,
-            *context.getDatabase(elem.to_database_name),
+            *database_catalog.getDatabase(elem.to_database_name),
             elem.to_table_name,
             from_table_lock);
     }

dbms/src/Interpreters/InterpreterShowCreateQuery.cpp

@@ -52,7 +52,7 @@ BlockInputStreamPtr InterpreterShowCreateQuery::executeImpl()
         else
         {
             context.checkAccess(AccessType::SHOW, show_query->database, show_query->table);
-            create_query = context.getDatabase(show_query->database)->getCreateTableQuery(context, show_query->table);
+            create_query = DatabaseCatalog::instance().getDatabase(show_query->database, context)->getCreateTableQuery(context, show_query->table);
         }
     }
     else if ((show_query = query_ptr->as<ASTShowCreateDatabaseQuery>()))
@@ -60,14 +60,14 @@ BlockInputStreamPtr InterpreterShowCreateQuery::executeImpl()
         if (show_query->temporary)
             throw Exception("Temporary databases are not possible.", ErrorCodes::SYNTAX_ERROR);
         context.checkAccess(AccessType::SHOW, show_query->database);
-        create_query = context.getDatabase(show_query->database)->getCreateDatabaseQuery(context);
+        create_query = DatabaseCatalog::instance().getDatabase(show_query->database)->getCreateDatabaseQuery(context);
     }
     else if ((show_query = query_ptr->as<ASTShowCreateDictionaryQuery>()))
     {
         if (show_query->temporary)
             throw Exception("Temporary dictionaries are not possible.", ErrorCodes::SYNTAX_ERROR);
         context.checkAccess(AccessType::SHOW, show_query->database, show_query->table);
-        create_query = context.getDatabase(show_query->database)->getCreateDictionaryQuery(context, show_query->table);
+        create_query = DatabaseCatalog::instance().getDatabase(show_query->database, context)->getCreateDictionaryQuery(context, show_query->table);
     }
 
     if (!create_query && show_query && show_query->temporary)

dbms/src/Interpreters/InterpreterShowTablesQuery.cpp

@@ -36,8 +36,8 @@ String InterpreterShowTablesQuery::getRewrittenQuery()
     if (query.temporary && !query.from.empty())
         throw Exception("The `FROM` and `TEMPORARY` cannot be used together in `SHOW TABLES`", ErrorCodes::SYNTAX_ERROR);
 
-    String database = query.from.empty() ? context.getCurrentDatabase() : query.from;
-    context.getDatabaseCatalog().assertDatabaseExists(database);
+    String database = context.resolveDatabase(query.from);
+    DatabaseCatalog::instance().assertDatabaseExists(database);
 
     std::stringstream rewritten_query;
     rewritten_query << "SELECT name FROM system.";

dbms/src/Interpreters/InterpreterSystemQuery.cpp

@@ -7,6 +7,7 @@
 #include <Common/ThreadPool.h>
 #include <Common/escapeForFileName.h>
 #include <Interpreters/Context.h>
+#include <Interpreters/DatabaseCatalog.h>
 #include <Interpreters/ExternalDictionariesLoader.h>
 #include <Interpreters/EmbeddedDictionaries.h>
 #include <Interpreters/ActionLocksManager.h>
@@ -135,7 +136,7 @@ void startStopAction(Context & context, Poco::Logger * log, ASTSystemQuery & que
     }
     else
     {
-        for (auto & elem : context.getDatabases())
+        for (auto & elem : DatabaseCatalog::instance().getDatabases())
         {
             for (auto iterator = elem.second->getTablesIterator(context); iterator->isValid(); iterator->next())
             {
@@ -312,7 +313,7 @@ BlockIO InterpreterSystemQuery::execute()
 StoragePtr InterpreterSystemQuery::tryRestartReplica(const String & database_name, const String & table_name, Context & system_context)
 {
     context.checkAccess(AccessType::RESTART_REPLICA, database_name, table_name);
-    auto database = system_context.getDatabase(database_name);
+    auto database = DatabaseCatalog::instance().getDatabase(database_name, system_context);
 
     auto table_ddl_guard = system_context.getDDLGuard(database_name, table_name);
     ASTPtr create_ast;
@@ -361,7 +362,7 @@ void InterpreterSystemQuery::restartReplicas(Context & system_context)
 {
     std::vector<std::pair<String, String>> replica_names;
 
-    for (auto & elem : system_context.getDatabases())
+    for (auto & elem : DatabaseCatalog::instance().getDatabases())
     {
         DatabasePtr & database = elem.second;
         const String & database_name = elem.first;

dbms/src/Interpreters/loadMetadata.cpp

@@ -140,7 +140,7 @@ void loadMetadataSystem(Context & context)
         Poco::File(global_path + "metadata/" SYSTEM_DATABASE).createDirectories();
 
         auto system_database = std::make_shared<DatabaseOrdinary>(SYSTEM_DATABASE, global_path + "metadata/" SYSTEM_DATABASE "/", context);
-        context.addDatabase(SYSTEM_DATABASE, system_database);
+        DatabaseCatalog::instance().attachDatabase(SYSTEM_DATABASE, system_database);
     }
 
 }

dbms/src/Interpreters/tests/create_query.cpp

@@ -83,7 +83,7 @@ try
 
     context.setPath("./");
     auto database = std::make_shared<DatabaseOrdinary>("test", "./metadata/test/", context);
-    context.addDatabase("test", database);
+    DatabaseCatalog::instance().attachDatabase("test", database);
     database->loadStoredObjects(context, false);
     context.setCurrentDatabase("test");
 

dbms/src/Interpreters/tests/expression_analyzer.cpp

@@ -100,7 +100,7 @@ int main()
     context.makeGlobalContext();
 
     auto system_database = std::make_shared<DatabaseMemory>("system");
-    context.addDatabase("system", system_database);
+    DatabaseCatalog::instance().attachDatabase("system", system_database);
     //context.setCurrentDatabase("system");
     system_database->attachTable("one", StorageSystemOne::create("one"));
     system_database->attachTable("numbers", StorageSystemNumbers::create("numbers", false));

dbms/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp

@@ -1166,7 +1166,7 @@ TestResult check(const TestEntry & entry)
         auto storage_distributed_hits = StorageDistributedFake::create("distant_db", "distant_hits", entry.shard_count);
 
         DB::DatabasePtr database = std::make_shared<DB::DatabaseOrdinary>("test", "./metadata/test/", context);
-        context.addDatabase("test", database);
+        DB::DatabaseCatalog::instance().attachDatabase("test", database);
         database->attachTable("visits_all", storage_distributed_visits);
         database->attachTable("hits_all", storage_distributed_hits);
         context.setCurrentDatabase("test");
@@ -1209,12 +1209,12 @@ TestResult check(const TestEntry & entry)
         bool res = equals(ast_input, ast_expected);
         std::string output = DB::queryToString(ast_input);
 
-        context.detachDatabase("test");
+        DB::DatabaseCatalog::instance().detachDatabase("test");
         return TestResult(res, output);
     }
     catch (DB::Exception & e)
     {
-        context.detachDatabase("test");
+        DB::DatabaseCatalog::instance().detachDatabase("test");
         return TestResult(false, e.displayText());
     }
 }

dbms/src/Interpreters/tests/select_query.cpp

@@ -38,9 +38,9 @@ try
     loadMetadata(context);
 
     DatabasePtr system = std::make_shared<DatabaseOrdinary>("system", "./metadata/system/", context);
-    context.addDatabase("system", system);
+    DatabaseCatalog::instance().attachDatabase("system", system);
     system->loadStoredObjects(context, false);
-    attachSystemTablesLocal(*context.getDatabase("system"));
+    attachSystemTablesLocal(*DatabaseCatalog::instance().getSystemDatabase());
     context.setCurrentDatabase("default");
 
     ReadBufferFromFileDescriptor in(STDIN_FILENO);

dbms/src/Storages/IStorage.cpp

@@ -387,7 +387,7 @@ void IStorage::alter(
     auto table_id = getStorageID();
     StorageInMemoryMetadata metadata = getInMemoryMetadata();
     params.apply(metadata);
-    context.getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
     setColumns(std::move(metadata.columns));
 }
 

dbms/src/Storages/StorageBuffer.cpp

@@ -765,7 +765,7 @@ void StorageBuffer::alter(const AlterCommands & params, const Context & context,
 
     StorageInMemoryMetadata metadata = getInMemoryMetadata();
     params.apply(metadata);
-    context.getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
     setColumns(std::move(metadata.columns));
 }
 

dbms/src/Storages/StorageDistributed.cpp

@@ -469,7 +469,7 @@ void StorageDistributed::alter(const AlterCommands & params, const Context & con
     checkAlterIsPossible(params, context.getSettingsRef());
     StorageInMemoryMetadata metadata = getInMemoryMetadata();
     params.apply(metadata);
-    context.getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
     setColumns(std::move(metadata.columns));
 }
 

dbms/src/Storages/StorageMaterializedView.cpp

@@ -294,7 +294,7 @@ void StorageMaterializedView::alter(
     }
     /// end modify query
 
-    context.getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
     setColumns(std::move(metadata.columns));
 }
 

dbms/src/Storages/StorageMerge.cpp

@@ -399,7 +399,7 @@ StorageMerge::StorageListWithLocks StorageMerge::getSelectedTables(const ASTPtr
 DatabaseTablesIteratorPtr StorageMerge::getDatabaseIterator(const Context & context) const
 {
     checkStackSize();
-    auto database = context.getDatabase(source_database);
+    auto database = DatabaseCatalog::instance().getDatabase(source_database, context);
     auto table_name_match = [this](const String & table_name_) { return table_name_regexp.match(table_name_); };
     return database->getTablesIterator(global_context, table_name_match);
 }
@@ -425,7 +425,7 @@ void StorageMerge::alter(
 
     StorageInMemoryMetadata storage_metadata = getInMemoryMetadata();
     params.apply(storage_metadata);
-    context.getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, storage_metadata);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, storage_metadata);
     setColumns(storage_metadata.columns);
 }
 

dbms/src/Storages/StorageMergeTree.cpp

@@ -272,7 +272,7 @@ void StorageMergeTree::alter(
     {
         lockStructureExclusively(table_lock_holder, context.getCurrentQueryId());
 
-        context.getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
+        DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
 
         update_metadata();
     }
@@ -289,7 +289,7 @@ void StorageMergeTree::alter(
 
         lockStructureExclusively(table_lock_holder, context.getCurrentQueryId());
 
-        context.getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
+        DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
 
         update_metadata();
 

dbms/src/Storages/StorageNull.cpp

@@ -51,7 +51,7 @@ void StorageNull::alter(
 
     StorageInMemoryMetadata metadata = getInMemoryMetadata();
     params.apply(metadata);
-    context.getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(context, table_id.table_name, metadata);
     setColumns(std::move(metadata.columns));
 }
 

dbms/src/Storages/StorageReplicatedMergeTree.cpp

@@ -541,7 +541,7 @@ void StorageReplicatedMergeTree::setTableStructure(ColumnsDescription new_column
     }
 
     auto table_id = getStorageID();
-    global_context.getDatabase(table_id.database_name)->alterTable(global_context, table_id.table_name, metadata);
+    DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(global_context, table_id.table_name, metadata);
 
     /// Even if the primary/sorting keys didn't change we must reinitialize it
     /// because primary key column types might have changed.
@@ -3231,7 +3231,7 @@ void StorageReplicatedMergeTree::alter(
 
         changeSettings(metadata.settings_ast, table_lock_holder);
 
-        global_context.getDatabase(table_id.database_name)->alterTable(query_context, table_id.table_name, metadata);
+        DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(query_context, table_id.table_name, metadata);
         return;
     }
 
@@ -3309,7 +3309,7 @@ void StorageReplicatedMergeTree::alter(
             auto old_metadata = getInMemoryMetadata();
             old_metadata.settings_ast = metadata.settings_ast;
             changeSettings(metadata.settings_ast, table_lock_holder);
-            global_context.getDatabase(table_id.database_name)->alterTable(query_context, table_id.table_name, old_metadata);
+            DatabaseCatalog::instance().getDatabase(table_id.database_name)->alterTable(query_context, table_id.table_name, old_metadata);
         }
 
         /// Modify shared metadata nodes in ZooKeeper.

dbms/src/Storages/System/StorageSystemColumns.cpp

@@ -267,7 +267,7 @@ Pipes StorageSystemColumns::readWithProcessors(
     Pipes pipes;
 
     {
-        Databases databases = context.getDatabases();
+        Databases databases = DatabaseCatalog::instance().getDatabases();
 
         /// Add `database` column.
         MutableColumnPtr database_column_mut = ColumnString::create();

dbms/src/Storages/System/StorageSystemDatabases.cpp

@@ -23,7 +23,7 @@ void StorageSystemDatabases::fillData(MutableColumns & res_columns, const Contex
     const auto access_rights = context.getAccessRights();
     const bool check_access_for_databases = !access_rights->isGranted(AccessType::SHOW);
 
-    auto databases = context.getDatabases();
+    auto databases = DatabaseCatalog::instance().getDatabases();
     for (const auto & database : databases)
     {
         if (check_access_for_databases && !access_rights->isGranted(AccessType::SHOW, database.first))

dbms/src/Storages/System/StorageSystemGraphite.cpp

@@ -27,7 +27,7 @@ NamesAndTypesList StorageSystemGraphite::getNamesAndTypes()
  */
 StorageSystemGraphite::Configs StorageSystemGraphite::getConfigs(const Context & context) const
 {
-    const Databases databases = context.getDatabases();
+    const Databases databases = DatabaseCatalog::instance().getDatabases();
     Configs graphite_configs;
 
     for (const auto & db : databases)

dbms/src/Storages/System/StorageSystemMutations.cpp

@@ -42,7 +42,7 @@ void StorageSystemMutations::fillData(MutableColumns & res_columns, const Contex
 
     /// Collect a set of *MergeTree tables.
     std::map<String, std::map<String, StoragePtr>> merge_tree_tables;
-    for (const auto & db : context.getDatabases())
+    for (const auto & db : DatabaseCatalog::instance().getDatabases())
     {
         /// Lazy database can not contain MergeTree tables
         if (db.second->getEngineName() == "Lazy")

dbms/src/Storages/System/StorageSystemPartsBase.cpp

@@ -76,7 +76,7 @@ StoragesInfoStream::StoragesInfoStream(const SelectQueryInfo & query_info, const
     const bool check_access_for_tables = !access_rights->isGranted(AccessType::SHOW);
 
     {
-        Databases databases = context.getDatabases();
+        Databases databases = DatabaseCatalog::instance().getDatabases();
 
         /// Add column 'database'.
         MutableColumnPtr database_column_mut = ColumnString::create();

dbms/src/Storages/System/StorageSystemReplicas.cpp

@@ -69,7 +69,7 @@ Pipes StorageSystemReplicas::readWithProcessors(
 
     /// We collect a set of replicated tables.
     std::map<String, std::map<String, StoragePtr>> replicated_tables;
-    for (const auto & db : context.getDatabases())
+    for (const auto & db : DatabaseCatalog::instance().getDatabases())
     {
         /// Lazy database can not contain replicated tables
         if (db.second->getEngineName() == "Lazy")

dbms/src/Storages/System/StorageSystemReplicationQueue.cpp

@@ -53,7 +53,7 @@ void StorageSystemReplicationQueue::fillData(MutableColumns & res_columns, const
     const bool check_access_for_databases = !access_rights->isGranted(AccessType::SHOW);
 
     std::map<String, std::map<String, StoragePtr>> replicated_tables;
-    for (const auto & db : context.getDatabases())
+    for (const auto & db : DatabaseCatalog::instance().getDatabases())
     {
         /// Lazy database can not contain replicated tables
         if (db.second->getEngineName() == "Lazy")

dbms/src/Storages/System/StorageSystemTables.cpp

@@ -57,7 +57,7 @@ StorageSystemTables::StorageSystemTables(const std::string & name_)
 static ColumnPtr getFilteredDatabases(const ASTPtr & query, const Context & context)
 {
     MutableColumnPtr column = ColumnString::create();
-    for (const auto & db : context.getDatabases())
+    for (const auto & db : DatabaseCatalog::instance().getDatabases())
         column->insert(db.first);
 
     Block block { ColumnWithTypeAndName(std::move(column), std::make_shared<DataTypeString>(), "database") };
@@ -118,7 +118,8 @@ protected:
             while (database_idx < databases->size() && (!tables_it || !tables_it->isValid()))
             {
                 database_name = databases->getDataAt(database_idx).toString();
-                database = context.tryGetDatabase(database_name);
+                //FIXME access is not checked
+                database = DatabaseCatalog::instance().tryGetDatabase(database_name);
 
                 if (!database)
                 {

dbms/src/Storages/tests/gtest_transform_query_for_external_database.cpp

@@ -32,7 +32,8 @@ struct State
         registerFunctions();
         DatabasePtr database = std::make_shared<DatabaseMemory>("test");
         database->attachTable("table", StorageMemory::create(StorageID("test", "table"), ColumnsDescription{columns}, ConstraintsDescription{}));
-        context.addDatabase("test", database);
+        context.makeGlobalContext();
+        DatabaseCatalog::instance().attachDatabase("test", database);
         context.setCurrentDatabase("test");
     }
 };

dbms/src/TableFunctions/TableFunctionMerge.cpp

@@ -31,7 +31,7 @@ static NamesAndTypesList chooseColumns(const String & source_database, const Str
     StoragePtr any_table;
 
     {
-        auto database = context.getDatabase(source_database);
+        auto database = DatabaseCatalog::instance().getDatabase(source_database);
         auto iterator = database->getTablesIterator(context, table_name_match);
 
         if (iterator->isValid())