ClickHouse/dbms/src/Interpreters/InterpreterDropQuery.cpp

291 lines
10 KiB
C++
Raw Normal View History

2011-11-05 23:31:19 +00:00
#include <Poco/File.h>
#include <Databases/IDatabase.h>
2017-05-23 18:01:50 +00:00
#include <Interpreters/Context.h>
#include <Interpreters/DDLWorker.h>
#include <Interpreters/InterpreterDropQuery.h>
2019-10-15 18:04:17 +00:00
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Parsers/ASTDropQuery.h>
#include <Storages/IStorage.h>
#include <Common/escapeForFileName.h>
#include <Common/quoteString.h>
#include <Common/typeid_cast.h>
2020-01-22 11:30:11 +00:00
#include <Databases/DatabaseAtomic.h>
2011-11-05 23:31:19 +00:00
namespace DB
{
2017-12-22 19:20:18 +00:00
namespace ErrorCodes
{
extern const int TABLE_WAS_NOT_DROPPED;
extern const int DATABASE_NOT_EMPTY;
extern const int UNKNOWN_DATABASE;
extern const int READONLY;
2018-04-21 00:35:20 +00:00
extern const int LOGICAL_ERROR;
2018-06-09 16:03:07 +00:00
extern const int SYNTAX_ERROR;
2018-04-21 00:35:20 +00:00
extern const int UNKNOWN_TABLE;
2018-09-11 18:37:19 +00:00
extern const int QUERY_IS_PROHIBITED;
extern const int UNKNOWN_DICTIONARY;
}
2011-11-05 23:31:19 +00:00
InterpreterDropQuery::InterpreterDropQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
2011-11-05 23:31:19 +00:00
2015-06-18 02:11:05 +00:00
BlockIO InterpreterDropQuery::execute()
{
auto & drop = query_ptr->as<ASTDropQuery &>();
checkAccess(drop);
if (!drop.cluster.empty())
return executeDDLQueryOnCluster(query_ptr, context, {drop.database});
if (!drop.table.empty())
{
if (!drop.is_dictionary)
return executeToTable(drop.database, drop.table, drop.kind, drop.if_exists, drop.temporary, drop.no_ddl_lock);
else
return executeToDictionary(drop.database, drop.table, drop.kind, drop.if_exists, drop.temporary, drop.no_ddl_lock);
}
else if (!drop.database.empty())
return executeToDatabase(drop.database, drop.kind, drop.if_exists);
2018-04-21 00:35:20 +00:00
else
throw Exception("Nothing to drop, both names are empty.", ErrorCodes::LOGICAL_ERROR);
2018-04-21 00:35:20 +00:00
}
BlockIO InterpreterDropQuery::executeToTable(
String & database_name_,
String & table_name,
ASTDropQuery::Kind kind,
bool if_exists,
bool if_temporary,
bool no_ddl_lock)
2018-04-21 00:35:20 +00:00
{
if (if_temporary || database_name_.empty())
{
2018-04-21 00:35:20 +00:00
auto & session_context = context.hasSessionContext() ? context.getSessionContext() : context;
if (session_context.isExternalTableExist(table_name))
return executeToTemporaryTable(table_name, kind);
}
2018-04-21 00:35:20 +00:00
String database_name = database_name_.empty() ? context.getCurrentDatabase() : database_name_;
2019-03-11 16:50:31 +00:00
auto ddl_guard = (!no_ddl_lock ? context.getDDLGuard(database_name, table_name) : nullptr);
2018-09-18 18:33:15 +00:00
2018-04-21 00:35:20 +00:00
DatabaseAndTable database_and_table = tryGetDatabaseAndTable(database_name, table_name, if_exists);
if (database_and_table.first && database_and_table.second)
{
auto table_id = database_and_table.second->getStorageID();
2018-04-21 00:35:20 +00:00
if (kind == ASTDropQuery::Kind::Detach)
{
2018-04-21 00:35:20 +00:00
database_and_table.second->shutdown();
/// If table was already dropped by anyone, an exception will be thrown
2019-03-05 10:12:20 +00:00
auto table_lock = database_and_table.second->lockExclusively(context.getCurrentQueryId());
2018-04-21 00:35:20 +00:00
/// Drop table from memory, don't touch data and metadata
database_and_table.first->detachTable(table_id.table_name);
2018-04-21 00:35:20 +00:00
}
else if (kind == ASTDropQuery::Kind::Truncate)
{
2018-08-03 09:54:46 +00:00
database_and_table.second->checkTableCanBeDropped();
2018-06-09 15:48:22 +00:00
2018-04-21 00:35:20 +00:00
/// If table was already dropped by anyone, an exception will be thrown
2019-03-05 10:12:20 +00:00
auto table_lock = database_and_table.second->lockExclusively(context.getCurrentQueryId());
2018-04-21 00:35:20 +00:00
/// Drop table data, don't touch metadata
2019-08-27 20:43:08 +00:00
database_and_table.second->truncate(query_ptr, context, table_lock);
2018-04-21 00:35:20 +00:00
}
else if (kind == ASTDropQuery::Kind::Drop)
{
2018-08-03 09:54:46 +00:00
database_and_table.second->checkTableCanBeDropped();
2018-04-21 00:35:20 +00:00
database_and_table.second->shutdown();
/// If table was already dropped by anyone, an exception will be thrown
2020-01-27 20:31:39 +00:00
TableStructureWriteLockHolder table_lock;
if (database_and_table.first->getEngineName() != "Atomic")
table_lock = database_and_table.second->lockExclusively(context.getCurrentQueryId());
2020-01-22 11:30:11 +00:00
database_and_table.first->dropTable(context, table_name);
2018-04-21 00:35:20 +00:00
}
}
return {};
}
BlockIO InterpreterDropQuery::executeToDictionary(
String & database_name_,
String & dictionary_name,
ASTDropQuery::Kind kind,
bool if_exists,
bool is_temporary,
bool no_ddl_lock)
{
if (is_temporary)
throw Exception("Temporary dictionaries are not possible.", ErrorCodes::SYNTAX_ERROR);
String database_name = database_name_.empty() ? context.getCurrentDatabase() : database_name_;
auto ddl_guard = (!no_ddl_lock ? context.getDDLGuard(database_name, dictionary_name) : nullptr);
DatabasePtr database = tryGetDatabase(database_name, if_exists);
if (!database || !database->isDictionaryExist(context, dictionary_name))
{
if (!if_exists)
throw Exception(
"Dictionary " + backQuoteIfNeed(database_name) + "." + backQuoteIfNeed(dictionary_name) + " doesn't exist.",
ErrorCodes::UNKNOWN_DICTIONARY);
else
return {};
}
if (kind == ASTDropQuery::Kind::Detach)
{
/// Drop dictionary from memory, don't touch data and metadata
2019-10-16 17:06:52 +00:00
database->detachDictionary(dictionary_name, context);
}
else if (kind == ASTDropQuery::Kind::Truncate)
{
throw Exception("Cannot TRUNCATE dictionary", ErrorCodes::SYNTAX_ERROR);
}
else if (kind == ASTDropQuery::Kind::Drop)
{
database->removeDictionary(context, dictionary_name);
}
return {};
}
2018-04-21 00:35:20 +00:00
BlockIO InterpreterDropQuery::executeToTemporaryTable(String & table_name, ASTDropQuery::Kind kind)
{
if (kind == ASTDropQuery::Kind::Detach)
throw Exception("Unable to detach temporary table.", ErrorCodes::SYNTAX_ERROR);
else
2018-04-21 00:35:20 +00:00
{
auto & context_handle = context.hasSessionContext() ? context.getSessionContext() : context;
StoragePtr table = context_handle.tryGetExternalTable(table_name);
2018-04-21 00:35:20 +00:00
if (table)
{
if (kind == ASTDropQuery::Kind::Truncate)
{
/// If table was already dropped by anyone, an exception will be thrown
2019-03-05 10:12:20 +00:00
auto table_lock = table->lockExclusively(context.getCurrentQueryId());
/// Drop table data, don't touch metadata
2019-08-27 20:43:08 +00:00
table->truncate(query_ptr, context, table_lock);
}
else if (kind == ASTDropQuery::Kind::Drop)
{
context_handle.tryRemoveExternalTable(table_name);
table->shutdown();
/// If table was already dropped by anyone, an exception will be thrown
2019-03-05 10:12:20 +00:00
auto table_lock = table->lockExclusively(context.getCurrentQueryId());
/// Delete table data
2020-01-22 11:30:11 +00:00
table->drop();
table->is_dropped = true;
}
}
}
2018-04-21 00:35:20 +00:00
return {};
}
2018-04-21 00:35:20 +00:00
BlockIO InterpreterDropQuery::executeToDatabase(String & database_name, ASTDropQuery::Kind kind, bool if_exists)
{
2018-09-18 18:33:15 +00:00
auto ddl_guard = context.getDDLGuard(database_name, "");
2018-04-21 00:35:20 +00:00
if (auto database = tryGetDatabase(database_name, if_exists))
{
2018-04-21 00:35:20 +00:00
if (kind == ASTDropQuery::Kind::Truncate)
{
2018-04-21 00:35:20 +00:00
throw Exception("Unable to truncate database.", ErrorCodes::SYNTAX_ERROR);
}
2018-04-21 00:35:20 +00:00
else if (kind == ASTDropQuery::Kind::Detach)
{
2018-04-21 00:35:20 +00:00
context.detachDatabase(database_name);
database->shutdown();
}
2018-04-21 00:35:20 +00:00
else if (kind == ASTDropQuery::Kind::Drop)
{
2019-10-10 17:33:01 +00:00
for (auto iterator = database->getTablesIterator(context); iterator->isValid(); iterator->next())
2018-04-21 00:35:20 +00:00
{
2019-10-01 12:44:17 +00:00
String current_table_name = iterator->name();
2019-03-11 16:50:31 +00:00
executeToTable(database_name, current_table_name, kind, false, false, false);
2018-04-21 00:35:20 +00:00
}
2019-10-11 15:22:30 +00:00
for (auto iterator = database->getDictionariesIterator(context); iterator->isValid(); iterator->next())
{
String current_dictionary = iterator->name();
executeToDictionary(database_name, current_dictionary, kind, false, false, false);
}
2020-01-28 19:39:52 +00:00
//FIXME get rid of global context lock here
2018-04-21 00:35:20 +00:00
auto context_lock = context.getLock();
2018-04-21 00:35:20 +00:00
/// Someone could have time to delete the database before us.
context.assertDatabaseExists(database_name);
2018-04-21 00:35:20 +00:00
/// 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))
throw Exception("New table appeared in database being dropped. Try dropping it again.", ErrorCodes::DATABASE_NOT_EMPTY);
2018-04-21 00:35:20 +00:00
database->shutdown();
2018-06-09 15:48:22 +00:00
2018-04-21 00:35:20 +00:00
/// Delete the database.
2019-10-25 19:07:47 +00:00
database->drop(context);
2020-01-28 19:39:52 +00:00
/// Delete database information from the RAM
context.detachDatabase(database_name);
2018-06-09 15:48:22 +00:00
/// Old ClickHouse versions did not store database.sql files
Poco::File database_metadata_file(context.getPath() + "metadata/" + escapeForFileName(database_name) + ".sql");
if (database_metadata_file.exists())
database_metadata_file.remove(false);
}
}
2018-04-21 00:35:20 +00:00
return {};
}
2018-04-21 00:35:20 +00:00
DatabasePtr InterpreterDropQuery::tryGetDatabase(String & database_name, bool if_exists)
{
return if_exists ? context.tryGetDatabase(database_name) : context.getDatabase(database_name);
}
2018-04-21 00:35:20 +00:00
DatabaseAndTable InterpreterDropQuery::tryGetDatabaseAndTable(String & database_name, String & table_name, bool if_exists)
{
DatabasePtr database = tryGetDatabase(database_name, if_exists);
2018-04-21 00:35:20 +00:00
if (database)
{
StoragePtr table = database->tryGetTable(context, table_name);
if (!table && !if_exists)
throw Exception("Table " + backQuoteIfNeed(database_name) + "." + backQuoteIfNeed(table_name) + " doesn't exist.",
ErrorCodes::UNKNOWN_TABLE);
return {std::move(database), std::move(table)};
}
return {};
}
void InterpreterDropQuery::checkAccess(const ASTDropQuery & drop)
{
const Settings & settings = context.getSettingsRef();
auto readonly = settings.readonly;
2018-09-11 18:37:19 +00:00
bool allow_ddl = settings.allow_ddl;
2015-12-13 12:02:10 +00:00
2017-12-22 19:20:18 +00:00
/// It's allowed to drop temporary tables.
2018-09-11 18:37:19 +00:00
if ((!readonly && allow_ddl) || (drop.database.empty() && context.tryGetExternalTable(drop.table) && readonly >= 2))
return;
2018-09-11 18:37:19 +00:00
if (readonly)
throw Exception("Cannot drop table in readonly mode", ErrorCodes::READONLY);
throw Exception("Cannot drop table. DDL queries are prohibited for the user", ErrorCodes::QUERY_IS_PROHIBITED);
}
2017-12-22 19:20:18 +00:00
2011-11-05 23:31:19 +00:00
}