Move NamedCollectionsFactory to a separate file

src/Common/NamedCollections/NamedCollectionUtils.cpp

@@ -16,6 +16,7 @@
 #include <Interpreters/Context.h>
 #include <Common/NamedCollections/NamedCollections.h>
 #include <Common/NamedCollections/NamedCollectionConfiguration.h>
+#include <Common/NamedCollections/NamedCollectionsFactory.h>
 
 #include <filesystem>
 

src/Common/NamedCollections/NamedCollections.cpp

@@ -6,7 +6,6 @@
 #include <Common/NamedCollections/NamedCollectionConfiguration.h>
 #include <Common/NamedCollections/NamedCollectionUtils.h>
 #include <Poco/Util/AbstractConfiguration.h>
-#include <ranges>
 
 
 namespace DB
@@ -22,162 +21,6 @@ namespace ErrorCodes
 
 namespace Configuration = NamedCollectionConfiguration;
 
-
-NamedCollectionFactory & NamedCollectionFactory::instance()
-{
-    static NamedCollectionFactory instance;
-    return instance;
-}
-
-bool NamedCollectionFactory::exists(const std::string & collection_name) const
-{
-    std::lock_guard lock(mutex);
-    return existsUnlocked(collection_name, lock);
-}
-
-bool NamedCollectionFactory::existsUnlocked(
-    const std::string & collection_name,
-    std::lock_guard<std::mutex> & /* lock */) const
-{
-    return loaded_named_collections.contains(collection_name);
-}
-
-NamedCollectionPtr NamedCollectionFactory::get(const std::string & collection_name) const
-{
-    std::lock_guard lock(mutex);
-    auto collection = tryGetUnlocked(collection_name, lock);
-    if (!collection)
-    {
-        throw Exception(
-            ErrorCodes::NAMED_COLLECTION_DOESNT_EXIST,
-            "There is no named collection `{}`",
-            collection_name);
-    }
-    return collection;
-}
-
-NamedCollectionPtr NamedCollectionFactory::tryGet(const std::string & collection_name) const
-{
-    std::lock_guard lock(mutex);
-    return tryGetUnlocked(collection_name, lock);
-}
-
-MutableNamedCollectionPtr NamedCollectionFactory::getMutable(
-    const std::string & collection_name) const
-{
-    std::lock_guard lock(mutex);
-    auto collection = tryGetUnlocked(collection_name, lock);
-    if (!collection)
-    {
-        throw Exception(
-            ErrorCodes::NAMED_COLLECTION_DOESNT_EXIST,
-            "There is no named collection `{}`",
-            collection_name);
-    }
-    else if (!collection->isMutable())
-    {
-        throw Exception(
-            ErrorCodes::NAMED_COLLECTION_IS_IMMUTABLE,
-            "Cannot get collection `{}` for modification, "
-            "because collection was defined as immutable",
-            collection_name);
-    }
-    return collection;
-}
-
-MutableNamedCollectionPtr NamedCollectionFactory::tryGetUnlocked(
-    const std::string & collection_name,
-    std::lock_guard<std::mutex> & /* lock */) const
-{
-    auto it = loaded_named_collections.find(collection_name);
-    if (it == loaded_named_collections.end())
-        return nullptr;
-    return it->second;
-}
-
-void NamedCollectionFactory::add(
-    const std::string & collection_name,
-    MutableNamedCollectionPtr collection)
-{
-    std::lock_guard lock(mutex);
-    addUnlocked(collection_name, collection, lock);
-}
-
-void NamedCollectionFactory::add(NamedCollectionsMap collections)
-{
-    std::lock_guard lock(mutex);
-    for (const auto & [collection_name, collection] : collections)
-        addUnlocked(collection_name, collection, lock);
-}
-
-void NamedCollectionFactory::addUnlocked(
-    const std::string & collection_name,
-    MutableNamedCollectionPtr collection,
-    std::lock_guard<std::mutex> & /* lock */)
-{
-    auto [it, inserted] = loaded_named_collections.emplace(collection_name, collection);
-    if (!inserted)
-    {
-        throw Exception(
-            ErrorCodes::NAMED_COLLECTION_ALREADY_EXISTS,
-            "A named collection `{}` already exists",
-            collection_name);
-    }
-}
-
-void NamedCollectionFactory::remove(const std::string & collection_name)
-{
-    std::lock_guard lock(mutex);
-    bool removed = removeIfExistsUnlocked(collection_name, lock);
-    if (!removed)
-    {
-        throw Exception(
-            ErrorCodes::NAMED_COLLECTION_DOESNT_EXIST,
-            "There is no named collection `{}`",
-            collection_name);
-    }
-}
-
-void NamedCollectionFactory::removeIfExists(const std::string & collection_name)
-{
-    std::lock_guard lock(mutex);
-    removeIfExistsUnlocked(collection_name, lock); // NOLINT
-}
-
-bool NamedCollectionFactory::removeIfExistsUnlocked(
-    const std::string & collection_name,
-    std::lock_guard<std::mutex> & lock)
-{
-    auto collection = tryGetUnlocked(collection_name, lock);
-    if (!collection)
-        return false;
-
-    if (!collection->isMutable())
-    {
-        throw Exception(
-            ErrorCodes::NAMED_COLLECTION_IS_IMMUTABLE,
-            "Cannot get collection `{}` for modification, "
-            "because collection was defined as immutable",
-            collection_name);
-    }
-    loaded_named_collections.erase(collection_name);
-    return true;
-}
-
-void NamedCollectionFactory::removeById(NamedCollectionUtils::SourceId id)
-{
-    std::lock_guard lock(mutex);
-    std::erase_if(
-        loaded_named_collections,
-        [&](const auto & value) { return value.second->getSourceId() == id; });
-}
-
-NamedCollectionsMap NamedCollectionFactory::getAll() const
-{
-    std::lock_guard lock(mutex);
-    return loaded_named_collections;
-}
-
 class NamedCollection::Impl
 {
 private:

src/Common/NamedCollections/NamedCollections.h

@@ -93,59 +93,4 @@ private:
     mutable std::mutex mutex;
 };
 
-/**
- * A factory of immutable named collections.
- */
-class NamedCollectionFactory : boost::noncopyable
-{
-public:
-    static NamedCollectionFactory & instance();
-
-    bool exists(const std::string & collection_name) const;
-
-    NamedCollectionPtr get(const std::string & collection_name) const;
-
-    NamedCollectionPtr tryGet(const std::string & collection_name) const;
-
-    MutableNamedCollectionPtr getMutable(const std::string & collection_name) const;
-
-    void add(const std::string & collection_name, MutableNamedCollectionPtr collection);
-
-    void add(NamedCollectionsMap collections);
-
-    void update(NamedCollectionsMap collections);
-
-    void remove(const std::string & collection_name);
-
-    void removeIfExists(const std::string & collection_name);
-
-    void removeById(NamedCollectionUtils::SourceId id);
-
-    NamedCollectionsMap getAll() const;
-
-private:
-    bool existsUnlocked(
-        const std::string & collection_name,
-        std::lock_guard<std::mutex> & lock) const;
-
-    MutableNamedCollectionPtr tryGetUnlocked(
-        const std::string & collection_name,
-        std::lock_guard<std::mutex> & lock) const;
-
-    void addUnlocked(
-        const std::string & collection_name,
-        MutableNamedCollectionPtr collection,
-        std::lock_guard<std::mutex> & lock);
-
-    bool removeIfExistsUnlocked(
-        const std::string & collection_name,
-        std::lock_guard<std::mutex> & lock);
-
-    mutable NamedCollectionsMap loaded_named_collections;
-
-    mutable std::mutex mutex;
-    bool is_initialized = false;
-};
-
-
 }

src/Common/NamedCollections/NamedCollectionsFactory.cpp

@@ -0,0 +1,169 @@
+#include <Common/NamedCollections/NamedCollectionsFactory.h>
+#include <Common/NamedCollections/NamedCollectionUtils.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int NAMED_COLLECTION_DOESNT_EXIST;
+    extern const int NAMED_COLLECTION_ALREADY_EXISTS;
+    extern const int NAMED_COLLECTION_IS_IMMUTABLE;
+}
+
+NamedCollectionFactory & NamedCollectionFactory::instance()
+{
+    static NamedCollectionFactory instance;
+    return instance;
+}
+
+bool NamedCollectionFactory::exists(const std::string & collection_name) const
+{
+    std::lock_guard lock(mutex);
+    return existsUnlocked(collection_name, lock);
+}
+
+bool NamedCollectionFactory::existsUnlocked(
+    const std::string & collection_name,
+    std::lock_guard<std::mutex> & /* lock */) const
+{
+    return loaded_named_collections.contains(collection_name);
+}
+
+NamedCollectionPtr NamedCollectionFactory::get(const std::string & collection_name) const
+{
+    std::lock_guard lock(mutex);
+    auto collection = tryGetUnlocked(collection_name, lock);
+    if (!collection)
+    {
+        throw Exception(
+            ErrorCodes::NAMED_COLLECTION_DOESNT_EXIST,
+            "There is no named collection `{}`",
+            collection_name);
+    }
+    return collection;
+}
+
+NamedCollectionPtr NamedCollectionFactory::tryGet(const std::string & collection_name) const
+{
+    std::lock_guard lock(mutex);
+    return tryGetUnlocked(collection_name, lock);
+}
+
+MutableNamedCollectionPtr NamedCollectionFactory::getMutable(
+    const std::string & collection_name) const
+{
+    std::lock_guard lock(mutex);
+    auto collection = tryGetUnlocked(collection_name, lock);
+    if (!collection)
+    {
+        throw Exception(
+            ErrorCodes::NAMED_COLLECTION_DOESNT_EXIST,
+            "There is no named collection `{}`",
+            collection_name);
+    }
+    else if (!collection->isMutable())
+    {
+        throw Exception(
+            ErrorCodes::NAMED_COLLECTION_IS_IMMUTABLE,
+            "Cannot get collection `{}` for modification, "
+            "because collection was defined as immutable",
+            collection_name);
+    }
+    return collection;
+}
+
+MutableNamedCollectionPtr NamedCollectionFactory::tryGetUnlocked(
+    const std::string & collection_name,
+    std::lock_guard<std::mutex> & /* lock */) const
+{
+    auto it = loaded_named_collections.find(collection_name);
+    if (it == loaded_named_collections.end())
+        return nullptr;
+    return it->second;
+}
+
+void NamedCollectionFactory::add(
+    const std::string & collection_name,
+    MutableNamedCollectionPtr collection)
+{
+    std::lock_guard lock(mutex);
+    addUnlocked(collection_name, collection, lock);
+}
+
+void NamedCollectionFactory::add(NamedCollectionsMap collections)
+{
+    std::lock_guard lock(mutex);
+    for (const auto & [collection_name, collection] : collections)
+        addUnlocked(collection_name, collection, lock);
+}
+
+void NamedCollectionFactory::addUnlocked(
+    const std::string & collection_name,
+    MutableNamedCollectionPtr collection,
+    std::lock_guard<std::mutex> & /* lock */)
+{
+    auto [it, inserted] = loaded_named_collections.emplace(collection_name, collection);
+    if (!inserted)
+    {
+        throw Exception(
+            ErrorCodes::NAMED_COLLECTION_ALREADY_EXISTS,
+            "A named collection `{}` already exists",
+            collection_name);
+    }
+}
+
+void NamedCollectionFactory::remove(const std::string & collection_name)
+{
+    std::lock_guard lock(mutex);
+    bool removed = removeIfExistsUnlocked(collection_name, lock);
+    if (!removed)
+    {
+        throw Exception(
+            ErrorCodes::NAMED_COLLECTION_DOESNT_EXIST,
+            "There is no named collection `{}`",
+            collection_name);
+    }
+}
+
+void NamedCollectionFactory::removeIfExists(const std::string & collection_name)
+{
+    std::lock_guard lock(mutex);
+    removeIfExistsUnlocked(collection_name, lock); // NOLINT
+}
+
+bool NamedCollectionFactory::removeIfExistsUnlocked(
+    const std::string & collection_name,
+    std::lock_guard<std::mutex> & lock)
+{
+    auto collection = tryGetUnlocked(collection_name, lock);
+    if (!collection)
+        return false;
+
+    if (!collection->isMutable())
+    {
+        throw Exception(
+            ErrorCodes::NAMED_COLLECTION_IS_IMMUTABLE,
+            "Cannot get collection `{}` for modification, "
+            "because collection was defined as immutable",
+            collection_name);
+    }
+    loaded_named_collections.erase(collection_name);
+    return true;
+}
+
+void NamedCollectionFactory::removeById(NamedCollectionUtils::SourceId id)
+{
+    std::lock_guard lock(mutex);
+    std::erase_if(
+        loaded_named_collections,
+        [&](const auto & value) { return value.second->getSourceId() == id; });
+}
+
+NamedCollectionsMap NamedCollectionFactory::getAll() const
+{
+    std::lock_guard lock(mutex);
+    return loaded_named_collections;
+}
+
+}

src/Common/NamedCollections/NamedCollectionsFactory.h

@@ -0,0 +1,57 @@
+#include <Common/NamedCollections/NamedCollections.h>
+
+namespace DB
+{
+
+class NamedCollectionFactory : boost::noncopyable
+{
+public:
+    static NamedCollectionFactory & instance();
+
+    bool exists(const std::string & collection_name) const;
+
+    NamedCollectionPtr get(const std::string & collection_name) const;
+
+    NamedCollectionPtr tryGet(const std::string & collection_name) const;
+
+    MutableNamedCollectionPtr getMutable(const std::string & collection_name) const;
+
+    void add(const std::string & collection_name, MutableNamedCollectionPtr collection);
+
+    void add(NamedCollectionsMap collections);
+
+    void update(NamedCollectionsMap collections);
+
+    void remove(const std::string & collection_name);
+
+    void removeIfExists(const std::string & collection_name);
+
+    void removeById(NamedCollectionUtils::SourceId id);
+
+    NamedCollectionsMap getAll() const;
+
+private:
+    bool existsUnlocked(
+        const std::string & collection_name,
+        std::lock_guard<std::mutex> & lock) const;
+
+    MutableNamedCollectionPtr tryGetUnlocked(
+        const std::string & collection_name,
+        std::lock_guard<std::mutex> & lock) const;
+
+    void addUnlocked(
+        const std::string & collection_name,
+        MutableNamedCollectionPtr collection,
+        std::lock_guard<std::mutex> & lock);
+
+    bool removeIfExistsUnlocked(
+        const std::string & collection_name,
+        std::lock_guard<std::mutex> & lock);
+
+    mutable NamedCollectionsMap loaded_named_collections;
+
+    mutable std::mutex mutex;
+    bool is_initialized = false;
+};
+
+}

src/Common/tests/gtest_named_collections.cpp

@@ -1,5 +1,5 @@
 #include <Common/tests/gtest_global_context.h>
-#include <Common/NamedCollections/NamedCollections.h>
+#include <Common/NamedCollections/NamedCollectionsFactory.h>
 #include <Common/NamedCollections/NamedCollectionUtils.h>
 #include <Poco/Util/XMLConfiguration.h>
 #include <Poco/DOM/DOMParser.h>

src/Disks/ObjectStorages/Cached/registerDiskCache.cpp

@@ -4,7 +4,7 @@
 #include <Common/logger_useful.h>
 #include <Common/assert_cast.h>
 #include <Common/filesystemHelpers.h>
-#include <Common/NamedCollections/NamedCollections.h>
+#include <Common/NamedCollections/NamedCollectionsFactory.h>
 #include <Disks/DiskFactory.h>
 #include <Disks/ObjectStorages/DiskObjectStorage.h>
 

src/Storages/Kafka/StorageKafka.cpp

@@ -29,6 +29,7 @@
 #include <Storages/Kafka/KafkaSource.h>
 #include <Storages/MessageQueueSink.h>
 #include <Storages/NamedCollectionsHelpers.h>
+#include <Common/NamedCollections/NamedCollectionsFactory.h>
 #include <Storages/StorageFactory.h>
 #include <Storages/StorageMaterializedView.h>
 #include <base/getFQDNOrHostName.h>

src/Storages/NamedCollectionsHelpers.cpp

@@ -1,6 +1,7 @@
 #include "NamedCollectionsHelpers.h"
 #include <Access/ContextAccess.h>
 #include <Common/NamedCollections/NamedCollections.h>
+#include <Common/NamedCollections/NamedCollectionsFactory.h>
 #include <Interpreters/evaluateConstantExpression.h>
 #include <Storages/checkAndGetLiteralArgument.h>
 #include <Parsers/ASTIdentifier.h>

src/Storages/System/StorageSystemNamedCollections.cpp

@@ -9,7 +9,7 @@
 #include <Access/Common/AccessFlags.h>
 #include <Access/ContextAccess.h>
 #include <Columns/ColumnMap.h>
-#include <Common/NamedCollections/NamedCollections.h>
+#include <Common/NamedCollections/NamedCollectionsFactory.h>
 
 
 namespace DB