mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-09-20 00:30:49 +00:00
move databases from Context to DatabaseCatalog
This commit is contained in:
parent
4ff7bf78ab
commit
869e20d207
@ -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.
|
||||
|
@ -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);
|
||||
|
@ -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)
|
||||
|
@ -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)
|
||||
{
|
||||
|
@ -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()
|
||||
|
@ -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());
|
||||
|
||||
|
@ -1,5 +1,6 @@
|
||||
#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;
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
}
|
||||
|
@ -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)
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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)
|
||||
|
@ -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.";
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -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");
|
||||
|
||||
|
@ -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));
|
||||
|
@ -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());
|
||||
}
|
||||
}
|
||||
|
@ -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);
|
||||
|
@ -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));
|
||||
}
|
||||
|
||||
|
@ -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));
|
||||
}
|
||||
|
||||
|
@ -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));
|
||||
}
|
||||
|
||||
|
@ -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));
|
||||
}
|
||||
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
|
@ -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();
|
||||
|
||||
|
@ -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));
|
||||
}
|
||||
|
||||
|
@ -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.
|
||||
|
@ -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();
|
||||
|
@ -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))
|
||||
|
@ -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)
|
||||
|
@ -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")
|
||||
|
@ -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();
|
||||
|
@ -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")
|
||||
|
@ -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")
|
||||
|
@ -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)
|
||||
{
|
||||
|
@ -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");
|
||||
}
|
||||
};
|
||||
|
@ -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())
|
||||
|
Loading…
Reference in New Issue
Block a user