initial refactor of db registration

src/Databases/DatabaseAtomic.cpp

@@ -1,6 +1,7 @@
 #include <Databases/DatabaseAtomic.h>
 #include <Databases/DatabaseOnDisk.h>
 #include <Databases/DatabaseReplicated.h>
+#include <Databases/DatabaseFactory.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <IO/ReadBufferFromFile.h>
@@ -622,4 +623,16 @@ void DatabaseAtomic::checkDetachedTableNotInUse(const UUID & uuid)
     assertDetachedTableNotInUse(uuid);
 }
 
+void registerDatabaseAtomic(DatabaseFactory & factory)
+{
+    auto create_fn = [](const DatabaseFactory::Arguments & args)
+    {
+        return make_shared<DatabaseAtomic>(
+            args.database_name,
+            args.metadata_path,
+            args.uuid,
+            args.context);
+    };
+    factory.registerDatabase("Atomic", create_fn);
+}
 }

src/Databases/DatabaseDictionary.cpp

@@ -1,4 +1,5 @@
 #include <Databases/DatabaseDictionary.h>
+#include <Databases/DatabaseFactory.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/ExternalDictionariesLoader.h>
 #include <Dictionaries/DictionaryStructure.h>
@@ -140,4 +141,14 @@ void DatabaseDictionary::shutdown()
 {
 }
 
+void registerDatabaseDictionary(DatabaseFactory & factory)
+{
+    auto create_fn = [](const DatabaseFactory::Arguments & args)
+    {
+        return make_shared<DatabaseDictionary>(
+            args.database_name,
+            args.context);
+    };
+    factory.registerDatabase("Dictionary", create_fn);
+}
 }

src/Databases/DatabaseFactory.cpp

@@ -119,6 +119,18 @@ DatabasePtr DatabaseFactory::get(const ASTCreateQuery & create, const String & m
     return impl;
 }
 
+void DatabaseFactory::registerDatabase(const std::string & name, CreatorFn creator_fn)
+{
+    if (!databases.emplace(name, Creator{std::move(creator_fn)}).second)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "DatabaseFactory: the database name '{}' is not unique", name);
+}
+
+DatabaseFactory & DatabaseFactory::instance()
+{
+    static DatabaseFactory db_fact;
+    return db_fact;
+}
+
 template <typename ValueType>
 static inline ValueType safeGetLiteralValue(const ASTPtr &ast, const String &engine_name)
 {

src/Databases/DatabaseFactory.h

@@ -8,12 +8,39 @@ namespace DB
 
 class ASTCreateQuery;
 
-class DatabaseFactory
+class DatabaseFactory : private boost::noncopyable
 {
 public:
-    static DatabasePtr get(const ASTCreateQuery & create, const String & metadata_path, ContextPtr context);
 
-    static DatabasePtr getImpl(const ASTCreateQuery & create, const String & metadata_path, ContextPtr context);
+    static DatabaseFactory & instance();
+
+    struct Arguments
+    {
+        const String & database_name;
+        const String & metadata_path;
+        const UUID & uuid;
+        const ContextPtr & context;
+        const UInt64 & cache_expiration_time_seconds;
+    };
+
+    DatabasePtr get(const ASTCreateQuery & create, const String & metadata_path, ContextPtr context);
+
+    DatabasePtr getImpl(const ASTCreateQuery & create, const String & metadata_path, ContextPtr context);
+
+    using CreatorFn = std::function<DatabasePtr(const Arguments & arguments)>;
+
+    struct Creator
+    {
+        CreatorFn creator_fn;
+    };
+    using Databases = std::unordered_map<std::string, Creator>;
+
+    void registerDatabase(const std::string & name, CreatorFn creator_fn);
+
+    const Databases & getAllDatabases() const { return databases; }
+
+private:
+    Databases databases;
 };
 
 }

src/Databases/DatabaseFilesystem.cpp

@@ -1,3 +1,4 @@
+#include <Databases/DatabaseFactory.h>
 #include <Databases/DatabaseFilesystem.h>
 
 #include <IO/Operators.h>
@@ -237,4 +238,15 @@ DatabaseTablesIteratorPtr DatabaseFilesystem::getTablesIterator(ContextPtr, cons
     return std::make_unique<DatabaseTablesSnapshotIterator>(Tables{}, getDatabaseName());
 }
 
+void registerDatabaseFilesystem(DatabaseFactory & factory)
+{
+    auto create_fn = [](const DatabaseFactory::Arguments & args)
+    {
+        return make_shared<DatabaseFilesystem>(
+            args.database_name,
+            args.metadata_path,
+            args.context);
+    };
+    factory.registerDatabase("FileSystem", create_fn);
+}
 }

src/Databases/DatabaseLazy.cpp

@@ -1,4 +1,5 @@
 #include <Core/Settings.h>
+#include <Databases/DatabaseFactory.h>
 #include <Databases/DatabaseLazy.h>
 #include <Databases/DatabaseOnDisk.h>
 #include <Databases/DatabasesCommon.h>
@@ -354,4 +355,16 @@ const StoragePtr & DatabaseLazyIterator::table() const
     return current_storage;
 }
 
+void registerDatabaseLazy(DatabaseFactory & factory)
+{
+    auto create_fn = [](const DatabaseFactory::Arguments & args)
+    {
+        return make_shared<DatabaseLazy>(
+            args.database_name,
+            args.metadata_path,
+            args.cache_expiration_time_seconds,
+            args.context);
+    };
+    factory.registerDatabase("Lazy", create_fn);
+}
 }

src/Databases/DatabaseMemory.cpp

@@ -1,5 +1,6 @@
 #include <base/scope_guard.h>
 #include <Common/logger_useful.h>
+#include <Databases/DatabaseFactory.h>
 #include <Databases/DatabaseMemory.h>
 #include <Databases/DatabasesCommon.h>
 #include <Databases/DDLDependencyVisitor.h>
@@ -209,4 +210,15 @@ std::vector<std::pair<ASTPtr, StoragePtr>> DatabaseMemory::getTablesForBackup(co
     return res;
 }
 
+void registerDatabaseMemory(DatabaseFactory & factory)
+{
+    auto create_fn = [](const DatabaseFactory::Arguments & args)
+    {
+        return make_shared<DatabaseMemory>(
+            args.database_name,
+            args.context);
+    };
+    factory.registerDatabase("Memory", create_fn);
+}
+
 }

src/Databases/DatabaseOrdinary.cpp

@@ -1,6 +1,7 @@
 #include <filesystem>
 
 #include <Core/Settings.h>
+#include <Databases/DatabaseFactory.h>
 #include <Databases/DatabaseOnDisk.h>
 #include <Databases/DatabaseOrdinary.h>
 #include <Databases/DatabasesCommon.h>
@@ -321,4 +322,15 @@ void DatabaseOrdinary::commitAlterTable(const StorageID &, const String & table_
     }
 }
 
+void registerDatabaseOrdinary(DatabaseFactory & factory)
+{
+    auto create_fn = [](const DatabaseFactory::Arguments & args)
+    {
+        return make_shared<DatabaseOrdinary>(
+            args.database_name,
+            args.metadata_path,
+            args.context);
+    };
+    factory.registerDatabase("Ordinary", create_fn);
+}
 }

src/Databases/registerDatabases.cpp

@@ -0,0 +1,26 @@
+#include <Databases/DatabaseFactory.h>
+#include <Databases/registerDatabases.h>
+
+
+namespace DB
+{
+
+void registerDatabaseAtomic(DatabaseFactory & factory);
+void registerDatabaseOrdinary(DatabaseFactory & factory);
+void registerDatabaseDictionary(DatabaseFactory & factory);
+void registerDatabaseMemory(DatabaseFactory & factory);
+void registerDatabaseLazy(DatabaseFactory & factory);
+void registerDatabaseFilesystem(DatabaseFactory & factory);
+
+
+void registerDatabases()
+{
+    auto & factory = DatabaseFactory::instance();
+    registerDatabaseAtomic(factory);
+    registerDatabaseOrdinary(factory);
+    registerDatabaseDictionary(factory);
+    registerDatabaseMemory(factory);
+    registerDatabaseLazy(factory);
+    registerDatabaseFilesystem(factory);
+}
+}

src/Databases/registerDatabases.h

@@ -0,0 +1,4 @@
+namespace DB
+{
+void registerDatabases();
+}

src/Interpreters/InterpreterCreateQuery.cpp

@@ -282,7 +282,7 @@ BlockIO InterpreterCreateQuery::createDatabase(ASTCreateQuery & create)
     else if (create.uuid != UUIDHelpers::Nil && !DatabaseCatalog::instance().hasUUIDMapping(create.uuid))
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot find UUID mapping for {}, it's a bug", create.uuid);
 
-    DatabasePtr database = DatabaseFactory::get(create, metadata_path / "", getContext());
+    DatabasePtr database = DatabaseFactory::instance().get(create, metadata_path / "", getContext());
 
     if (create.uuid != UUIDHelpers::Nil)
         create.setDatabase(TABLE_WITH_UUID_NAME_PLACEHOLDER);