2019-05-17 14:34:25 +00:00
|
|
|
#include <Databases/DatabasesCommon.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Interpreters/InterpreterCreateQuery.h>
|
2019-05-17 14:34:25 +00:00
|
|
|
#include <Parsers/ParserCreateQuery.h>
|
|
|
|
#include <Parsers/formatAST.h>
|
2019-10-17 13:05:12 +00:00
|
|
|
#include <Storages/StorageDictionary.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Storages/StorageFactory.h>
|
2019-05-17 14:34:25 +00:00
|
|
|
#include <Common/typeid_cast.h>
|
2019-07-18 18:29:49 +00:00
|
|
|
#include <TableFunctions/TableFunctionFactory.h>
|
2016-03-26 03:03:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
namespace DB
|
|
|
|
{
|
|
|
|
|
2017-10-27 21:18:06 +00:00
|
|
|
namespace ErrorCodes
|
|
|
|
{
|
2018-03-23 20:46:43 +00:00
|
|
|
extern const int TABLE_ALREADY_EXISTS;
|
|
|
|
extern const int UNKNOWN_TABLE;
|
2017-10-27 21:18:06 +00:00
|
|
|
}
|
|
|
|
|
2019-11-06 16:05:04 +00:00
|
|
|
DatabaseWithOwnTablesBase::DatabaseWithOwnTablesBase(const String & name_, const String & logger)
|
|
|
|
: IDatabase(name_), log(&Logger::get(logger))
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2018-03-23 20:46:43 +00:00
|
|
|
bool DatabaseWithOwnTablesBase::isTableExist(
|
|
|
|
const Context & /*context*/,
|
|
|
|
const String & table_name) const
|
|
|
|
{
|
2019-01-02 06:44:36 +00:00
|
|
|
std::lock_guard lock(mutex);
|
2019-10-17 13:05:12 +00:00
|
|
|
return tables.find(table_name) != tables.end() || dictionaries.find(table_name) != dictionaries.end();
|
2018-03-23 20:46:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
StoragePtr DatabaseWithOwnTablesBase::tryGetTable(
|
2019-11-05 20:26:14 +00:00
|
|
|
const Context & /*context*/,
|
2018-03-23 20:46:43 +00:00
|
|
|
const String & table_name) const
|
|
|
|
{
|
2019-11-05 20:26:14 +00:00
|
|
|
std::lock_guard lock(mutex);
|
|
|
|
auto it = tables.find(table_name);
|
|
|
|
if (it != tables.end())
|
|
|
|
return it->second;
|
2019-10-17 17:18:54 +00:00
|
|
|
return {};
|
2018-03-23 20:46:43 +00:00
|
|
|
}
|
|
|
|
|
2019-10-10 17:33:01 +00:00
|
|
|
DatabaseTablesIteratorPtr DatabaseWithOwnTablesBase::getTablesIterator(const Context & /*context*/, const FilterByNameFunction & filter_by_table_name)
|
2018-03-23 20:46:43 +00:00
|
|
|
{
|
2019-01-02 06:44:36 +00:00
|
|
|
std::lock_guard lock(mutex);
|
2019-06-02 12:11:01 +00:00
|
|
|
if (!filter_by_table_name)
|
2019-10-10 17:33:01 +00:00
|
|
|
return std::make_unique<DatabaseTablesSnapshotIterator>(tables);
|
2019-10-17 13:05:12 +00:00
|
|
|
|
2019-06-02 12:11:01 +00:00
|
|
|
Tables filtered_tables;
|
|
|
|
for (const auto & [table_name, storage] : tables)
|
|
|
|
if (filter_by_table_name(table_name))
|
|
|
|
filtered_tables.emplace(table_name, storage);
|
2019-10-17 13:05:12 +00:00
|
|
|
|
2019-10-10 17:33:01 +00:00
|
|
|
return std::make_unique<DatabaseTablesSnapshotIterator>(std::move(filtered_tables));
|
|
|
|
}
|
|
|
|
|
2018-03-23 20:46:43 +00:00
|
|
|
bool DatabaseWithOwnTablesBase::empty(const Context & /*context*/) const
|
|
|
|
{
|
2019-01-02 06:44:36 +00:00
|
|
|
std::lock_guard lock(mutex);
|
2019-10-10 17:33:01 +00:00
|
|
|
return tables.empty() && dictionaries.empty();
|
2018-03-23 20:46:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
StoragePtr DatabaseWithOwnTablesBase::detachTable(const String & table_name)
|
2020-01-30 12:51:47 +00:00
|
|
|
{
|
|
|
|
std::lock_guard lock(mutex);
|
|
|
|
return detachTableUnlocked(table_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
StoragePtr DatabaseWithOwnTablesBase::detachTableUnlocked(const String & table_name)
|
2018-03-23 20:46:43 +00:00
|
|
|
{
|
|
|
|
StoragePtr res;
|
2020-01-30 12:51:47 +00:00
|
|
|
if (dictionaries.count(table_name))
|
|
|
|
throw Exception("Cannot detach dictionary " + database_name + "." + table_name + " as table, use DETACH DICTIONARY query.", ErrorCodes::UNKNOWN_TABLE);
|
|
|
|
|
|
|
|
auto it = tables.find(table_name);
|
|
|
|
if (it == tables.end())
|
|
|
|
throw Exception("Table " + backQuote(database_name) + "." + backQuote(table_name) + " doesn't exist.", ErrorCodes::UNKNOWN_TABLE);
|
|
|
|
res = it->second;
|
|
|
|
tables.erase(it);
|
2018-03-23 20:46:43 +00:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DatabaseWithOwnTablesBase::attachTable(const String & table_name, const StoragePtr & table)
|
|
|
|
{
|
2019-01-02 06:44:36 +00:00
|
|
|
std::lock_guard lock(mutex);
|
2020-01-30 12:51:47 +00:00
|
|
|
attachTableUnlocked(table_name, table);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DatabaseWithOwnTablesBase::attachTableUnlocked(const String & table_name, const StoragePtr & table)
|
|
|
|
{
|
2018-03-23 20:46:43 +00:00
|
|
|
if (!tables.emplace(table_name, table).second)
|
2019-11-01 12:47:55 +00:00
|
|
|
throw Exception("Table " + database_name + "." + table_name + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS);
|
2018-03-23 20:46:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DatabaseWithOwnTablesBase::shutdown()
|
|
|
|
{
|
|
|
|
/// You can not hold a lock during shutdown.
|
|
|
|
/// Because inside `shutdown` function tables can work with database, and mutex is not recursive.
|
|
|
|
|
|
|
|
Tables tables_snapshot;
|
|
|
|
{
|
2019-01-02 06:44:36 +00:00
|
|
|
std::lock_guard lock(mutex);
|
2018-03-23 20:46:43 +00:00
|
|
|
tables_snapshot = tables;
|
|
|
|
}
|
|
|
|
|
2018-06-09 15:48:22 +00:00
|
|
|
for (const auto & kv : tables_snapshot)
|
2018-03-23 20:46:43 +00:00
|
|
|
{
|
|
|
|
kv.second->shutdown();
|
|
|
|
}
|
|
|
|
|
2019-01-02 06:44:36 +00:00
|
|
|
std::lock_guard lock(mutex);
|
2018-03-23 20:46:43 +00:00
|
|
|
tables.clear();
|
2019-10-14 09:52:43 +00:00
|
|
|
dictionaries.clear();
|
2018-03-23 20:46:43 +00:00
|
|
|
}
|
|
|
|
|
2018-03-23 20:56:45 +00:00
|
|
|
DatabaseWithOwnTablesBase::~DatabaseWithOwnTablesBase()
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2019-11-06 16:05:04 +00:00
|
|
|
DatabaseWithOwnTablesBase::shutdown();
|
2018-03-23 20:56:45 +00:00
|
|
|
}
|
2018-11-23 18:52:00 +00:00
|
|
|
catch (...)
|
2018-03-23 20:56:45 +00:00
|
|
|
{
|
|
|
|
tryLogCurrentException(__PRETTY_FUNCTION__);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-26 03:03:50 +00:00
|
|
|
}
|