From 3321f4490484f914ef0004975166e5c02587d40b Mon Sep 17 00:00:00 2001 From: Alexander Tokmakov Date: Thu, 2 Apr 2020 01:41:29 +0300 Subject: [PATCH] add uuid to system.tables --- .../programs/server/ReplicasStatusHandler.cpp | 2 +- dbms/src/Databases/DatabaseAtomic.cpp | 21 ++++++++++++++++++ dbms/src/Databases/DatabaseAtomic.h | 3 +++ dbms/src/Databases/DatabaseDictionary.cpp | 19 ++++++++-------- dbms/src/Databases/DatabaseDictionary.h | 7 +++--- dbms/src/Databases/DatabaseFactory.cpp | 2 +- dbms/src/Databases/DatabaseLazy.cpp | 21 +++++++++--------- dbms/src/Databases/DatabaseLazy.h | 6 ++--- dbms/src/Databases/DatabaseMySQL.cpp | 4 ++-- dbms/src/Databases/DatabaseMySQL.h | 4 ++-- dbms/src/Databases/DatabaseOnDisk.cpp | 3 ++- dbms/src/Databases/DatabaseOnDisk.h | 1 + .../Databases/DatabaseWithDictionaries.cpp | 18 +++++++-------- dbms/src/Databases/DatabaseWithDictionaries.h | 6 ++--- dbms/src/Databases/DatabasesCommon.cpp | 2 +- dbms/src/Databases/DatabasesCommon.h | 2 +- dbms/src/Databases/IDatabase.h | 22 ++++++++++++++----- dbms/src/Interpreters/ActionLocksManager.cpp | 6 ++--- dbms/src/Interpreters/ActionLocksManager.h | 4 ---- dbms/src/Interpreters/AsynchronousMetrics.cpp | 2 +- dbms/src/Interpreters/Context.cpp | 2 +- ...ExternalLoaderDatabaseConfigRepository.cpp | 2 +- .../src/Interpreters/InterpreterDropQuery.cpp | 4 ++-- .../Interpreters/InterpreterSystemQuery.cpp | 4 ++-- dbms/src/Storages/StorageMerge.cpp | 2 +- .../Storages/System/StorageSystemColumns.cpp | 2 +- .../Storages/System/StorageSystemGraphite.cpp | 8 +++---- .../System/StorageSystemMutations.cpp | 2 +- .../System/StorageSystemPartsBase.cpp | 2 +- .../Storages/System/StorageSystemReplicas.cpp | 2 +- .../System/StorageSystemReplicationQueue.cpp | 2 +- .../Storages/System/StorageSystemTables.cpp | 13 +++++++++-- .../src/TableFunctions/TableFunctionMerge.cpp | 6 ++--- 33 files changed, 124 insertions(+), 82 deletions(-) diff --git a/dbms/programs/server/ReplicasStatusHandler.cpp b/dbms/programs/server/ReplicasStatusHandler.cpp index e0943e2682b..2f2aa5953b6 100644 --- a/dbms/programs/server/ReplicasStatusHandler.cpp +++ b/dbms/programs/server/ReplicasStatusHandler.cpp @@ -44,7 +44,7 @@ void ReplicasStatusHandler::handleRequest(Poco::Net::HTTPServerRequest & request if (db.second->getEngineName() == "Lazy") continue; - for (auto iterator = db.second->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = db.second->getTablesIterator(); iterator->isValid(); iterator->next()) { auto & table = iterator->table(); StorageReplicatedMergeTree * table_replicated = dynamic_cast(table.get()); diff --git a/dbms/src/Databases/DatabaseAtomic.cpp b/dbms/src/Databases/DatabaseAtomic.cpp index a9da008e419..871eac48647 100644 --- a/dbms/src/Databases/DatabaseAtomic.cpp +++ b/dbms/src/Databases/DatabaseAtomic.cpp @@ -18,6 +18,15 @@ namespace ErrorCodes extern const int CANNOT_ASSIGN_ALTER; } +class AtomicDatabaseTablesSnapshotIterator final : public DatabaseTablesSnapshotIterator +{ +public: + AtomicDatabaseTablesSnapshotIterator(DatabaseTablesSnapshotIterator && base) + : DatabaseTablesSnapshotIterator(std::move(base)) {} + UUID uuid() const override { return table()->getStorageID().uuid; } +}; + + DatabaseAtomic::DatabaseAtomic(String name_, String metadata_path_, Context & context_) : DatabaseOrdinary(name_, metadata_path_, context_) { @@ -233,5 +242,17 @@ void DatabaseAtomic::cleenupDetachedTables() } } +DatabaseTablesIteratorPtr DatabaseAtomic::getTablesIterator(const IDatabase::FilterByNameFunction & filter_by_table_name) +{ + auto base_iter = DatabaseWithOwnTablesBase::getTablesIterator(filter_by_table_name); + return std::make_unique(std::move(typeid_cast(*base_iter))); +} + +DatabaseTablesIteratorPtr DatabaseAtomic::getTablesWithDictionaryTablesIterator(const IDatabase::FilterByNameFunction & filter_by_dictionary_name) +{ + auto base_iter = DatabaseWithDictionaries::getTablesWithDictionaryTablesIterator(filter_by_dictionary_name); + return std::make_unique(std::move(typeid_cast(*base_iter))); +} + } diff --git a/dbms/src/Databases/DatabaseAtomic.h b/dbms/src/Databases/DatabaseAtomic.h index f02f4438f5d..ce2c2fd79ae 100644 --- a/dbms/src/Databases/DatabaseAtomic.h +++ b/dbms/src/Databases/DatabaseAtomic.h @@ -42,6 +42,9 @@ public: void loadStoredObjects(Context & context, bool has_force_restore_data_flag) override; void shutdown() override; + DatabaseTablesIteratorPtr getTablesIterator(const FilterByNameFunction & filter_by_table_name) override; + DatabaseTablesIteratorPtr getTablesWithDictionaryTablesIterator(const FilterByNameFunction & filter_by_dictionary_name) override; + private: void commitAlterTable(const StorageID & table_id, const String & table_metadata_tmp_path, const String & table_metadata_path) override; void commitCreateTable(const ASTCreateQuery & query, const StoragePtr & table, diff --git a/dbms/src/Databases/DatabaseDictionary.cpp b/dbms/src/Databases/DatabaseDictionary.cpp index 006eb1656a2..a1cf10f1c42 100644 --- a/dbms/src/Databases/DatabaseDictionary.cpp +++ b/dbms/src/Databases/DatabaseDictionary.cpp @@ -17,25 +17,26 @@ namespace ErrorCodes extern const int SYNTAX_ERROR; } -DatabaseDictionary::DatabaseDictionary(const String & name_) - : IDatabase(name_), - log(&Logger::get("DatabaseDictionary(" + database_name + ")")) +DatabaseDictionary::DatabaseDictionary(const String & name_, const Context & global_context_) + : IDatabase(name_) + , log(&Logger::get("DatabaseDictionary(" + database_name + ")")) + , global_context(global_context_.getGlobalContext()) { } -Tables DatabaseDictionary::listTables(const Context & context, const FilterByNameFunction & filter_by_name) +Tables DatabaseDictionary::listTables(const FilterByNameFunction & filter_by_name) { Tables tables; ExternalLoader::LoadResults load_results; if (filter_by_name) { /// If `filter_by_name` is set, we iterate through all dictionaries with such names. That's why we need to load all of them. - load_results = context.getExternalDictionariesLoader().tryLoad(filter_by_name); + load_results = global_context.getExternalDictionariesLoader().tryLoad(filter_by_name); } else { /// If `filter_by_name` isn't set, we iterate through only already loaded dictionaries. We don't try to load all dictionaries in this case. - load_results = context.getExternalDictionariesLoader().getCurrentLoadResults(); + load_results = global_context.getExternalDictionariesLoader().getCurrentLoadResults(); } for (const auto & load_result: load_results) @@ -47,7 +48,7 @@ Tables DatabaseDictionary::listTables(const Context & context, const FilterByNam auto dict_name = dict_ptr->getName(); const DictionaryStructure & dictionary_structure = dict_ptr->getStructure(); auto columns = StorageDictionary::getNamesAndTypes(dictionary_structure); - tables[dict_name] = StorageDictionary::create(StorageID(getDatabaseName(), dict_name), ColumnsDescription{columns}, context, true, dict_name); + tables[dict_name] = StorageDictionary::create(StorageID(getDatabaseName(), dict_name), ColumnsDescription{columns}, global_context, true, dict_name); } } return tables; @@ -75,9 +76,9 @@ StoragePtr DatabaseDictionary::tryGetTable( return {}; } -DatabaseTablesIteratorPtr DatabaseDictionary::getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) +DatabaseTablesIteratorPtr DatabaseDictionary::getTablesIterator(const FilterByNameFunction & filter_by_table_name) { - return std::make_unique(listTables(context, filter_by_table_name)); + return std::make_unique(listTables(filter_by_table_name)); } bool DatabaseDictionary::empty(const Context & context) const diff --git a/dbms/src/Databases/DatabaseDictionary.h b/dbms/src/Databases/DatabaseDictionary.h index b586cb1403f..d18d10ccb5e 100644 --- a/dbms/src/Databases/DatabaseDictionary.h +++ b/dbms/src/Databases/DatabaseDictionary.h @@ -22,7 +22,7 @@ namespace DB class DatabaseDictionary final : public IDatabase { public: - DatabaseDictionary(const String & name_); + DatabaseDictionary(const String & name_, const Context & global_context); String getEngineName() const override { @@ -37,7 +37,7 @@ public: const Context & context, const String & table_name) const override; - DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override; + DatabaseTablesIteratorPtr getTablesIterator(const FilterByNameFunction & filter_by_table_name) override; bool empty(const Context & context) const override; @@ -52,8 +52,9 @@ private: mutable std::mutex mutex; Poco::Logger * log; + const Context & global_context; - Tables listTables(const Context & context, const FilterByNameFunction & filter_by_name); + Tables listTables(const FilterByNameFunction & filter_by_name); }; } diff --git a/dbms/src/Databases/DatabaseFactory.cpp b/dbms/src/Databases/DatabaseFactory.cpp index 29cb24629d7..ebbf4710b04 100644 --- a/dbms/src/Databases/DatabaseFactory.cpp +++ b/dbms/src/Databases/DatabaseFactory.cpp @@ -70,7 +70,7 @@ DatabasePtr DatabaseFactory::getImpl( else if (engine_name == "Memory") return std::make_shared(database_name); else if (engine_name == "Dictionary") - return std::make_shared(database_name); + return std::make_shared(database_name, context); #if USE_MYSQL diff --git a/dbms/src/Databases/DatabaseLazy.cpp b/dbms/src/Databases/DatabaseLazy.cpp index 683d315d012..1faa41c547e 100644 --- a/dbms/src/Databases/DatabaseLazy.cpp +++ b/dbms/src/Databases/DatabaseLazy.cpp @@ -115,7 +115,7 @@ bool DatabaseLazy::isTableExist( } StoragePtr DatabaseLazy::tryGetTable( - const Context & context, + const Context & /*context*/, const String & table_name) const { SCOPE_EXIT({ clearExpiredTables(); }); @@ -135,10 +135,10 @@ StoragePtr DatabaseLazy::tryGetTable( } } - return loadTable(context, table_name); + return loadTable(table_name); } -DatabaseTablesIteratorPtr DatabaseLazy::getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) +DatabaseTablesIteratorPtr DatabaseLazy::getTablesIterator(const FilterByNameFunction & filter_by_table_name) { std::lock_guard lock(mutex); Strings filtered_tables; @@ -148,7 +148,7 @@ DatabaseTablesIteratorPtr DatabaseLazy::getTablesIterator(const Context & contex filtered_tables.push_back(table_name); } std::sort(filtered_tables.begin(), filtered_tables.end()); - return std::make_unique(*this, context, std::move(filtered_tables)); + return std::make_unique(*this, std::move(filtered_tables)); } bool DatabaseLazy::empty(const Context & /* context */) const @@ -218,7 +218,7 @@ DatabaseLazy::~DatabaseLazy() } } -StoragePtr DatabaseLazy::loadTable(const Context & context, const String & table_name) const +StoragePtr DatabaseLazy::loadTable(const String & table_name) const { SCOPE_EXIT({ clearExpiredTables(); }); @@ -229,9 +229,9 @@ StoragePtr DatabaseLazy::loadTable(const Context & context, const String & table try { StoragePtr table; - Context context_copy(context); /// some tables can change context, but not LogTables + Context context_copy(global_context); /// some tables can change context, but not LogTables - auto ast = parseQueryFromMetadata(log, context, table_metadata_path, /*throw_on_error*/ true, /*remove_empty*/false); + auto ast = parseQueryFromMetadata(log, global_context, table_metadata_path, /*throw_on_error*/ true, /*remove_empty*/false); if (ast) { auto & ast_create = ast->as(); @@ -299,10 +299,9 @@ void DatabaseLazy::clearExpiredTables() const } -DatabaseLazyIterator::DatabaseLazyIterator(DatabaseLazy & database_, const Context & context_, Strings && table_names_) +DatabaseLazyIterator::DatabaseLazyIterator(DatabaseLazy & database_, Strings && table_names_) : database(database_) , table_names(std::move(table_names_)) - , context(context_) , iterator(table_names.begin()) , current_storage(nullptr) { @@ -312,7 +311,7 @@ void DatabaseLazyIterator::next() { current_storage.reset(); ++iterator; - while (isValid() && !database.isTableExist(context, *iterator)) + while (isValid() && !database.isTableExist(database.global_context, *iterator)) ++iterator; } @@ -329,7 +328,7 @@ const String & DatabaseLazyIterator::name() const const StoragePtr & DatabaseLazyIterator::table() const { if (!current_storage) - current_storage = database.tryGetTable(context, *iterator); + current_storage = database.tryGetTable(database.global_context, *iterator); return current_storage; } diff --git a/dbms/src/Databases/DatabaseLazy.h b/dbms/src/Databases/DatabaseLazy.h index 99bdfea11ae..153157ce17a 100644 --- a/dbms/src/Databases/DatabaseLazy.h +++ b/dbms/src/Databases/DatabaseLazy.h @@ -61,7 +61,7 @@ public: bool empty(const Context & context) const override; - DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override; + DatabaseTablesIteratorPtr getTablesIterator(const FilterByNameFunction & filter_by_table_name) override; void attachTable(const String & table_name, const StoragePtr & table, const String & relative_table_path) override; @@ -104,7 +104,7 @@ private: mutable TablesCache tables_cache; mutable CacheExpirationQueue cache_expiration_queue; - StoragePtr loadTable(const Context & context, const String & table_name) const; + StoragePtr loadTable(const String & table_name) const; void clearExpiredTables() const; @@ -117,7 +117,6 @@ class DatabaseLazyIterator final : public IDatabaseTablesIterator public: DatabaseLazyIterator( DatabaseLazy & database_, - const Context & context_, Strings && table_names_); void next() override; @@ -128,7 +127,6 @@ public: private: const DatabaseLazy & database; const Strings table_names; - const Context context; Strings::const_iterator iterator; mutable StoragePtr current_storage; }; diff --git a/dbms/src/Databases/DatabaseMySQL.cpp b/dbms/src/Databases/DatabaseMySQL.cpp index dad42a6fd90..10d1189c031 100644 --- a/dbms/src/Databases/DatabaseMySQL.cpp +++ b/dbms/src/Databases/DatabaseMySQL.cpp @@ -62,7 +62,7 @@ DatabaseMySQL::DatabaseMySQL( const Context & global_context_, const String & database_name_, const String & metadata_path_, const ASTStorage * database_engine_define_, const String & database_name_in_mysql_, mysqlxx::Pool && pool) : IDatabase(database_name_) - , global_context(global_context_) + , global_context(global_context_.getGlobalContext()) , metadata_path(metadata_path_) , database_engine_define(database_engine_define_->clone()) , database_name_in_mysql(database_name_in_mysql_) @@ -86,7 +86,7 @@ bool DatabaseMySQL::empty(const Context &) const return true; } -DatabaseTablesIteratorPtr DatabaseMySQL::getTablesIterator(const Context &, const FilterByNameFunction & filter_by_table_name) +DatabaseTablesIteratorPtr DatabaseMySQL::getTablesIterator(const FilterByNameFunction & filter_by_table_name) { Tables tables; std::lock_guard lock(mutex); diff --git a/dbms/src/Databases/DatabaseMySQL.h b/dbms/src/Databases/DatabaseMySQL.h index 5a459cb3095..6d7f1a29e55 100644 --- a/dbms/src/Databases/DatabaseMySQL.h +++ b/dbms/src/Databases/DatabaseMySQL.h @@ -30,7 +30,7 @@ public: bool empty(const Context & context) const override; - DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override; + DatabaseTablesIteratorPtr getTablesIterator(const FilterByNameFunction & filter_by_table_name) override; ASTPtr getCreateDatabaseQuery(const Context & /*context*/) const override; @@ -60,7 +60,7 @@ protected: ASTPtr getCreateTableQueryImpl(const Context & context, const String & name, bool throw_on_error) const override; private: - Context global_context; + const Context & global_context; String metadata_path; ASTPtr database_engine_define; String database_name_in_mysql; diff --git a/dbms/src/Databases/DatabaseOnDisk.cpp b/dbms/src/Databases/DatabaseOnDisk.cpp index 2d13d6e13ab..a8a8e85d6ee 100644 --- a/dbms/src/Databases/DatabaseOnDisk.cpp +++ b/dbms/src/Databases/DatabaseOnDisk.cpp @@ -123,10 +123,11 @@ String getObjectDefinitionFromCreateQuery(const ASTPtr & query) return statement_stream.str(); } -DatabaseOnDisk::DatabaseOnDisk(const String & name, const String & metadata_path_, const String & logger, const Context &) +DatabaseOnDisk::DatabaseOnDisk(const String & name, const String & metadata_path_, const String & logger, const Context & context) : DatabaseWithOwnTablesBase(name, logger) , metadata_path(metadata_path_) , data_path("data/" + escapeForFileName(database_name) + "/") + , global_context(context.getGlobalContext()) { } diff --git a/dbms/src/Databases/DatabaseOnDisk.h b/dbms/src/Databases/DatabaseOnDisk.h index b7fa0b1b015..5c7e41343a4 100644 --- a/dbms/src/Databases/DatabaseOnDisk.h +++ b/dbms/src/Databases/DatabaseOnDisk.h @@ -91,6 +91,7 @@ protected: const String metadata_path; /*const*/ String data_path; + const Context & global_context; }; } diff --git a/dbms/src/Databases/DatabaseWithDictionaries.cpp b/dbms/src/Databases/DatabaseWithDictionaries.cpp index e849962aae3..cd1f69aef9b 100644 --- a/dbms/src/Databases/DatabaseWithDictionaries.cpp +++ b/dbms/src/Databases/DatabaseWithDictionaries.cpp @@ -173,17 +173,17 @@ StoragePtr DatabaseWithDictionaries::tryGetTable(const Context & context, const if (isDictionaryExist(context, table_name)) /// We don't need lock database here, because database doesn't store dictionary itself /// just metadata - return getDictionaryStorage(context, table_name); + return getDictionaryStorage(table_name); return {}; } DatabaseTablesIteratorPtr DatabaseWithDictionaries::getTablesWithDictionaryTablesIterator( - const Context & context, const FilterByNameFunction & filter_by_dictionary_name) + const FilterByNameFunction & filter_by_dictionary_name) { /// NOTE: it's not atomic - auto tables_it = getTablesIterator(context, filter_by_dictionary_name); - auto dictionaries_it = getDictionariesIterator(context, filter_by_dictionary_name); + auto tables_it = getTablesIterator(filter_by_dictionary_name); + auto dictionaries_it = getDictionariesIterator(filter_by_dictionary_name); Tables result; while (tables_it && tables_it->isValid()) @@ -195,7 +195,7 @@ DatabaseTablesIteratorPtr DatabaseWithDictionaries::getTablesWithDictionaryTable while (dictionaries_it && dictionaries_it->isValid()) { auto table_name = dictionaries_it->name(); - auto table_ptr = getDictionaryStorage(context, table_name); + auto table_ptr = getDictionaryStorage(table_name); if (table_ptr) result.emplace(table_name, table_ptr); dictionaries_it->next(); @@ -204,7 +204,7 @@ DatabaseTablesIteratorPtr DatabaseWithDictionaries::getTablesWithDictionaryTable return std::make_unique(result); } -DatabaseDictionariesIteratorPtr DatabaseWithDictionaries::getDictionariesIterator(const Context & /*context*/, const FilterByNameFunction & filter_by_dictionary_name) +DatabaseDictionariesIteratorPtr DatabaseWithDictionaries::getDictionariesIterator(const FilterByNameFunction & filter_by_dictionary_name) { std::lock_guard lock(mutex); if (!filter_by_dictionary_name) @@ -223,16 +223,16 @@ bool DatabaseWithDictionaries::isDictionaryExist(const Context & /*context*/, co return dictionaries.find(dictionary_name) != dictionaries.end(); } -StoragePtr DatabaseWithDictionaries::getDictionaryStorage(const Context & context, const String & table_name) const +StoragePtr DatabaseWithDictionaries::getDictionaryStorage(const String & table_name) const { auto dict_name = database_name + "." + table_name; - const auto & external_loader = context.getExternalDictionariesLoader(); + const auto & external_loader = global_context.getExternalDictionariesLoader(); auto dict_ptr = external_loader.tryGetDictionary(dict_name); if (dict_ptr) { const DictionaryStructure & dictionary_structure = dict_ptr->getStructure(); auto columns = StorageDictionary::getNamesAndTypes(dictionary_structure); - return StorageDictionary::create(StorageID(database_name, table_name), ColumnsDescription{columns}, context, true, dict_name); + return StorageDictionary::create(StorageID(database_name, table_name), ColumnsDescription{columns}, global_context, true, dict_name); } return nullptr; } diff --git a/dbms/src/Databases/DatabaseWithDictionaries.h b/dbms/src/Databases/DatabaseWithDictionaries.h index 407c564954b..4a3132a432a 100644 --- a/dbms/src/Databases/DatabaseWithDictionaries.h +++ b/dbms/src/Databases/DatabaseWithDictionaries.h @@ -20,9 +20,9 @@ public: StoragePtr tryGetTable(const Context & context, const String & table_name) const override; - DatabaseTablesIteratorPtr getTablesWithDictionaryTablesIterator(const Context & context, const FilterByNameFunction & filter_by_dictionary_name) override; + DatabaseTablesIteratorPtr getTablesWithDictionaryTablesIterator(const FilterByNameFunction & filter_by_dictionary_name) override; - DatabaseDictionariesIteratorPtr getDictionariesIterator(const Context & context, const FilterByNameFunction & filter_by_dictionary_name) override; + DatabaseDictionariesIteratorPtr getDictionariesIterator(const FilterByNameFunction & filter_by_dictionary_name) override; bool isDictionaryExist(const Context & context, const String & dictionary_name) const override; @@ -37,7 +37,7 @@ protected: void attachToExternalDictionariesLoader(Context & context); void detachFromExternalDictionariesLoader(); - StoragePtr getDictionaryStorage(const Context & context, const String & table_name) const; + StoragePtr getDictionaryStorage(const String & table_name) const; ASTPtr getCreateDictionaryQueryImpl(const Context & context, const String & dictionary_name, diff --git a/dbms/src/Databases/DatabasesCommon.cpp b/dbms/src/Databases/DatabasesCommon.cpp index 37c5b95dfb2..c1aea97e61c 100644 --- a/dbms/src/Databases/DatabasesCommon.cpp +++ b/dbms/src/Databases/DatabasesCommon.cpp @@ -42,7 +42,7 @@ StoragePtr DatabaseWithOwnTablesBase::tryGetTable( return {}; } -DatabaseTablesIteratorPtr DatabaseWithOwnTablesBase::getTablesIterator(const Context & /*context*/, const FilterByNameFunction & filter_by_table_name) +DatabaseTablesIteratorPtr DatabaseWithOwnTablesBase::getTablesIterator(const FilterByNameFunction & filter_by_table_name) { std::lock_guard lock(mutex); if (!filter_by_table_name) diff --git a/dbms/src/Databases/DatabasesCommon.h b/dbms/src/Databases/DatabasesCommon.h index 7f699c55422..b07224fbc13 100644 --- a/dbms/src/Databases/DatabasesCommon.h +++ b/dbms/src/Databases/DatabasesCommon.h @@ -33,7 +33,7 @@ public: StoragePtr detachTable(const String & table_name) override; - DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name) override; + DatabaseTablesIteratorPtr getTablesIterator(const FilterByNameFunction & filter_by_table_name) override; void shutdown() override; diff --git a/dbms/src/Databases/IDatabase.h b/dbms/src/Databases/IDatabase.h index 44ade7542bf..d9626fac934 100644 --- a/dbms/src/Databases/IDatabase.h +++ b/dbms/src/Databases/IDatabase.h @@ -42,15 +42,27 @@ public: virtual const StoragePtr & table() const = 0; virtual ~IDatabaseTablesIterator() = default; + + virtual UUID uuid() const { return UUIDHelpers::Nil; } }; /// Copies list of tables and iterates through such snapshot. -class DatabaseTablesSnapshotIterator final : public IDatabaseTablesIterator +class DatabaseTablesSnapshotIterator : public IDatabaseTablesIterator { private: Tables tables; Tables::iterator it; +protected: + DatabaseTablesSnapshotIterator(DatabaseTablesSnapshotIterator && other) + { + size_t idx = std::distance(other.tables.begin(), other.it); + std::swap(tables, other.tables); + other.it = other.tables.end(); + it = tables.begin(); + std::advance(it, idx); + } + public: DatabaseTablesSnapshotIterator(Tables & tables_) : tables(tables_), it(tables.begin()) {} @@ -133,18 +145,18 @@ public: /// Get an iterator that allows you to pass through all the tables. /// It is possible to have "hidden" tables that are not visible when passing through, but are visible if you get them by name using the functions above. - virtual DatabaseTablesIteratorPtr getTablesIterator(const Context & context, const FilterByNameFunction & filter_by_table_name = {}) = 0; + virtual DatabaseTablesIteratorPtr getTablesIterator(const FilterByNameFunction & filter_by_table_name = {}) = 0; /// Get an iterator to pass through all the dictionaries. - virtual DatabaseDictionariesIteratorPtr getDictionariesIterator(const Context & /*context*/, [[maybe_unused]] const FilterByNameFunction & filter_by_dictionary_name = {}) + virtual DatabaseDictionariesIteratorPtr getDictionariesIterator([[maybe_unused]] const FilterByNameFunction & filter_by_dictionary_name = {}) { return std::make_unique(); } /// Get an iterator to pass through all the tables and dictionary tables. - virtual DatabaseTablesIteratorPtr getTablesWithDictionaryTablesIterator(const Context & context, const FilterByNameFunction & filter_by_name = {}) + virtual DatabaseTablesIteratorPtr getTablesWithDictionaryTablesIterator(const FilterByNameFunction & filter_by_name = {}) { - return getTablesIterator(context, filter_by_name); + return getTablesIterator(filter_by_name); } /// Is the database empty. diff --git a/dbms/src/Interpreters/ActionLocksManager.cpp b/dbms/src/Interpreters/ActionLocksManager.cpp index 9ab220d0a84..fe5b3def658 100644 --- a/dbms/src/Interpreters/ActionLocksManager.cpp +++ b/dbms/src/Interpreters/ActionLocksManager.cpp @@ -20,17 +20,17 @@ namespace ActionLocks template -inline void forEachTable(Context & context, F && f) +inline void forEachTable(F && f) { for (auto & elem : DatabaseCatalog::instance().getDatabases()) - for (auto iterator = elem.second->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = elem.second->getTablesIterator(); iterator->isValid(); iterator->next()) f(iterator->table()); } void ActionLocksManager::add(StorageActionBlockType action_type) { - forEachTable(global_context, [&](const StoragePtr & table) { add(table, action_type); }); + forEachTable([&](const StoragePtr & table) { add(table, action_type); }); } void ActionLocksManager::add(const StorageID & table_id, StorageActionBlockType action_type) diff --git a/dbms/src/Interpreters/ActionLocksManager.h b/dbms/src/Interpreters/ActionLocksManager.h index 4d2f9bef256..039a95ce218 100644 --- a/dbms/src/Interpreters/ActionLocksManager.h +++ b/dbms/src/Interpreters/ActionLocksManager.h @@ -19,8 +19,6 @@ class Context; class ActionLocksManager { public: - explicit ActionLocksManager(Context & global_context_) : global_context(global_context_) {} - /// Adds new locks for each table void add(StorageActionBlockType action_type); /// Add new lock for a table if it has not been already added @@ -37,8 +35,6 @@ public: void cleanExpired(); private: - Context & global_context; - using StorageRawPtr = const IStorage *; using Locks = std::unordered_map; using StorageLocks = std::unordered_map; diff --git a/dbms/src/Interpreters/AsynchronousMetrics.cpp b/dbms/src/Interpreters/AsynchronousMetrics.cpp index 35a352b67b6..544b345c2bb 100644 --- a/dbms/src/Interpreters/AsynchronousMetrics.cpp +++ b/dbms/src/Interpreters/AsynchronousMetrics.cpp @@ -155,7 +155,7 @@ void AsynchronousMetrics::update() /// Lazy database can not contain MergeTree tables if (db.second->getEngineName() == "Lazy") continue; - for (auto iterator = db.second->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = db.second->getTablesIterator(); iterator->isValid(); iterator->next()) { ++total_number_of_tables; auto & table = iterator->table(); diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp index bc769b780d2..ebf27e624da 100644 --- a/dbms/src/Interpreters/Context.cpp +++ b/dbms/src/Interpreters/Context.cpp @@ -1957,7 +1957,7 @@ std::shared_ptr Context::getActionLocksManager() auto lock = getLock(); if (!shared->action_locks_manager) - shared->action_locks_manager = std::make_shared(getGlobalContext()); + shared->action_locks_manager = std::make_shared(); return shared->action_locks_manager; } diff --git a/dbms/src/Interpreters/ExternalLoaderDatabaseConfigRepository.cpp b/dbms/src/Interpreters/ExternalLoaderDatabaseConfigRepository.cpp index 10f99262da7..20d43b1b329 100644 --- a/dbms/src/Interpreters/ExternalLoaderDatabaseConfigRepository.cpp +++ b/dbms/src/Interpreters/ExternalLoaderDatabaseConfigRepository.cpp @@ -52,7 +52,7 @@ std::set ExternalLoaderDatabaseConfigRepository::getAllLoadablesDef { std::set result; const auto & dbname = database.getDatabaseName(); - auto itr = database.getDictionariesIterator(context); + auto itr = database.getDictionariesIterator(); while (itr && itr->isValid()) { result.insert(dbname + "." + itr->name()); diff --git a/dbms/src/Interpreters/InterpreterDropQuery.cpp b/dbms/src/Interpreters/InterpreterDropQuery.cpp index e6279de818c..da4e7f31d04 100644 --- a/dbms/src/Interpreters/InterpreterDropQuery.cpp +++ b/dbms/src/Interpreters/InterpreterDropQuery.cpp @@ -225,13 +225,13 @@ BlockIO InterpreterDropQuery::executeToDatabase(const String & database_name, AS ASTDropQuery query; query.kind = kind; query.database = database_name; - for (auto iterator = database->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = database->getTablesIterator(); iterator->isValid(); iterator->next()) { query.table = iterator->name(); executeToTable({query.database, query.table}, query); } - for (auto iterator = database->getDictionariesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = database->getDictionariesIterator(); iterator->isValid(); iterator->next()) { String current_dictionary = iterator->name(); executeToDictionary(database_name, current_dictionary, kind, false, false, false); diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.cpp b/dbms/src/Interpreters/InterpreterSystemQuery.cpp index 87ed4a1f749..891786db84d 100644 --- a/dbms/src/Interpreters/InterpreterSystemQuery.cpp +++ b/dbms/src/Interpreters/InterpreterSystemQuery.cpp @@ -140,7 +140,7 @@ void InterpreterSystemQuery::startStopAction(StorageActionBlockType action_type, auto access = context.getAccess(); for (auto & elem : DatabaseCatalog::instance().getDatabases()) { - for (auto iterator = elem.second->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = elem.second->getTablesIterator(); iterator->isValid(); iterator->next()) { if (!access->isGranted(log, getRequiredAccessType(action_type), elem.first, iterator->name())) continue; @@ -362,7 +362,7 @@ void InterpreterSystemQuery::restartReplicas(Context & system_context) for (auto & elem : DatabaseCatalog::instance().getDatabases()) { DatabasePtr & database = elem.second; - for (auto iterator = database->getTablesIterator(system_context); iterator->isValid(); iterator->next()) + for (auto iterator = database->getTablesIterator(); iterator->isValid(); iterator->next()) { if (dynamic_cast(iterator->table().get())) replica_names.emplace_back(iterator->table()->getStorageID()); diff --git a/dbms/src/Storages/StorageMerge.cpp b/dbms/src/Storages/StorageMerge.cpp index 657950c0bcb..d05f5137028 100644 --- a/dbms/src/Storages/StorageMerge.cpp +++ b/dbms/src/Storages/StorageMerge.cpp @@ -415,7 +415,7 @@ DatabaseTablesIteratorPtr StorageMerge::getDatabaseIterator() const checkStackSize(); auto database = DatabaseCatalog::instance().getDatabase(source_database); auto table_name_match = [this](const String & table_name_) { return table_name_regexp.match(table_name_); }; - return database->getTablesIterator(global_context, table_name_match); + return database->getTablesIterator(table_name_match); } diff --git a/dbms/src/Storages/System/StorageSystemColumns.cpp b/dbms/src/Storages/System/StorageSystemColumns.cpp index 9af8904ab26..b443cf7b6b5 100644 --- a/dbms/src/Storages/System/StorageSystemColumns.cpp +++ b/dbms/src/Storages/System/StorageSystemColumns.cpp @@ -302,7 +302,7 @@ Pipes StorageSystemColumns::read( const DatabasePtr database = databases.at(database_name); offsets[i] = i ? offsets[i - 1] : 0; - for (auto iterator = database->getTablesWithDictionaryTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = database->getTablesWithDictionaryTablesIterator(); iterator->isValid(); iterator->next()) { const String & table_name = iterator->name(); storages.emplace(std::piecewise_construct, diff --git a/dbms/src/Storages/System/StorageSystemGraphite.cpp b/dbms/src/Storages/System/StorageSystemGraphite.cpp index a6163f89182..e8cca255c56 100644 --- a/dbms/src/Storages/System/StorageSystemGraphite.cpp +++ b/dbms/src/Storages/System/StorageSystemGraphite.cpp @@ -25,7 +25,7 @@ NamesAndTypesList StorageSystemGraphite::getNamesAndTypes() /* * Looking for (Replicated)*GraphiteMergeTree and get all configuration parameters for them */ -static StorageSystemGraphite::Configs getConfigs(const Context & context) +static StorageSystemGraphite::Configs getConfigs() { const Databases databases = DatabaseCatalog::instance().getDatabases(); StorageSystemGraphite::Configs graphite_configs; @@ -36,7 +36,7 @@ static StorageSystemGraphite::Configs getConfigs(const Context & context) if (db.second->getEngineName() == "Lazy") continue; - for (auto iterator = db.second->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = db.second->getTablesIterator(); iterator->isValid(); iterator->next()) { auto & table = iterator->table(); @@ -71,9 +71,9 @@ static StorageSystemGraphite::Configs getConfigs(const Context & context) return graphite_configs; } -void StorageSystemGraphite::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const +void StorageSystemGraphite::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const { - Configs graphite_configs = getConfigs(context); + Configs graphite_configs = getConfigs(); for (const auto & config : graphite_configs) { diff --git a/dbms/src/Storages/System/StorageSystemMutations.cpp b/dbms/src/Storages/System/StorageSystemMutations.cpp index e7d9cc38671..968c67bc14a 100644 --- a/dbms/src/Storages/System/StorageSystemMutations.cpp +++ b/dbms/src/Storages/System/StorageSystemMutations.cpp @@ -50,7 +50,7 @@ void StorageSystemMutations::fillData(MutableColumns & res_columns, const Contex const bool check_access_for_tables = check_access_for_databases && !access->isGranted(AccessType::SHOW_TABLES, db.first); - for (auto iterator = db.second->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = db.second->getTablesIterator(); iterator->isValid(); iterator->next()) { if (!dynamic_cast(iterator->table().get())) continue; diff --git a/dbms/src/Storages/System/StorageSystemPartsBase.cpp b/dbms/src/Storages/System/StorageSystemPartsBase.cpp index c212b30d268..46a33dcf0cf 100644 --- a/dbms/src/Storages/System/StorageSystemPartsBase.cpp +++ b/dbms/src/Storages/System/StorageSystemPartsBase.cpp @@ -110,7 +110,7 @@ StoragesInfoStream::StoragesInfoStream(const SelectQueryInfo & query_info, const const DatabasePtr database = databases.at(database_name); offsets[i] = i ? offsets[i - 1] : 0; - for (auto iterator = database->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = database->getTablesIterator(); iterator->isValid(); iterator->next()) { String table_name = iterator->name(); StoragePtr storage = iterator->table(); diff --git a/dbms/src/Storages/System/StorageSystemReplicas.cpp b/dbms/src/Storages/System/StorageSystemReplicas.cpp index 251b45e44b6..734d0098d8d 100644 --- a/dbms/src/Storages/System/StorageSystemReplicas.cpp +++ b/dbms/src/Storages/System/StorageSystemReplicas.cpp @@ -76,7 +76,7 @@ Pipes StorageSystemReplicas::read( if (db.second->getEngineName() == "Lazy") continue; const bool check_access_for_tables = check_access_for_databases && !access->isGranted(AccessType::SHOW_TABLES, db.first); - for (auto iterator = db.second->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = db.second->getTablesIterator(); iterator->isValid(); iterator->next()) { if (!dynamic_cast(iterator->table().get())) continue; diff --git a/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp b/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp index 2c188cf3734..a6f0af8cc6c 100644 --- a/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp +++ b/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp @@ -60,7 +60,7 @@ void StorageSystemReplicationQueue::fillData(MutableColumns & res_columns, const const bool check_access_for_tables = check_access_for_databases && !access->isGranted(AccessType::SHOW_TABLES, db.first); - for (auto iterator = db.second->getTablesIterator(context); iterator->isValid(); iterator->next()) + for (auto iterator = db.second->getTablesIterator(); iterator->isValid(); iterator->next()) { if (!dynamic_cast(iterator->table().get())) continue; diff --git a/dbms/src/Storages/System/StorageSystemTables.cpp b/dbms/src/Storages/System/StorageSystemTables.cpp index 5d0aec921de..8f22df617cf 100644 --- a/dbms/src/Storages/System/StorageSystemTables.cpp +++ b/dbms/src/Storages/System/StorageSystemTables.cpp @@ -18,6 +18,7 @@ #include #include #include +#include namespace DB @@ -36,6 +37,7 @@ StorageSystemTables::StorageSystemTables(const std::string & name_) { {"database", std::make_shared()}, {"name", std::make_shared()}, + {"uuid", std::make_shared()}, {"engine", std::make_shared()}, {"is_temporary", std::make_shared()}, {"data_paths", std::make_shared(std::make_shared())}, @@ -74,7 +76,7 @@ static bool needLockStructure(const DatabasePtr & database, const Block & header if (database->getEngineName() != "Lazy") return true; - static const std::set columns_without_lock = { "database", "name", "metadata_modification_time" }; + static const std::set columns_without_lock = { "database", "name", "uuid", "metadata_modification_time" }; for (const auto & column : header.getColumnsWithTypeAndName()) { if (columns_without_lock.find(column.name) == columns_without_lock.end()) @@ -152,6 +154,10 @@ protected: if (columns_mask[src_index++]) res_columns[res_index++]->insert(table.first); + // uuid + if (columns_mask[src_index++]) + res_columns[res_index++]->insert(table.second->getStorageID().uuid); + // engine if (columns_mask[src_index++]) res_columns[res_index++]->insert(table.second->getName()); @@ -226,7 +232,7 @@ protected: const bool check_access_for_tables = check_access_for_databases && !access->isGranted(AccessType::SHOW_TABLES, database_name); if (!tables_it || !tables_it->isValid()) - tables_it = database->getTablesWithDictionaryTablesIterator(context); + tables_it = database->getTablesWithDictionaryTablesIterator(); const bool need_lock_structure = needLockStructure(database, getPort().getHeader()); @@ -265,6 +271,9 @@ protected: if (columns_mask[src_index++]) res_columns[res_index++]->insert(table_name); + if (columns_mask[src_index++]) + res_columns[res_index++]->insert(tables_it->uuid()); + if (columns_mask[src_index++]) { assert(table != nullptr); diff --git a/dbms/src/TableFunctions/TableFunctionMerge.cpp b/dbms/src/TableFunctions/TableFunctionMerge.cpp index 1ced074761b..f0f5c7eff19 100644 --- a/dbms/src/TableFunctions/TableFunctionMerge.cpp +++ b/dbms/src/TableFunctions/TableFunctionMerge.cpp @@ -23,7 +23,7 @@ namespace ErrorCodes } -static NamesAndTypesList chooseColumns(const String & source_database, const String & table_name_regexp_, const Context & context) +static NamesAndTypesList chooseColumns(const String & source_database, const String & table_name_regexp_) { OptimizedRegularExpression table_name_regexp(table_name_regexp_); auto table_name_match = [&](const String & table_name) { return table_name_regexp.match(table_name); }; @@ -32,7 +32,7 @@ static NamesAndTypesList chooseColumns(const String & source_database, const Str { auto database = DatabaseCatalog::instance().getDatabase(source_database); - auto iterator = database->getTablesIterator(context, table_name_match); + auto iterator = database->getTablesIterator(table_name_match); if (iterator->isValid()) any_table = iterator->table(); @@ -72,7 +72,7 @@ StoragePtr TableFunctionMerge::executeImpl(const ASTPtr & ast_function, const Co auto res = StorageMerge::create( StorageID(getDatabaseName(), table_name), - ColumnsDescription{chooseColumns(source_database, table_name_regexp, context)}, + ColumnsDescription{chooseColumns(source_database, table_name_regexp)}, source_database, table_name_regexp, context);