Method executeToDatabaseImpl

src/Interpreters/InterpreterDropQuery.cpp:457–793

}

BlockIO InterpreterDropQuery::executeToDatabaseImpl(const ASTDropQuery & query, DatabasePtr & database, std::vector<UUID> & uuids_to_wait)
{
    if (query.kind != ASTDropQuery::Kind::Detach && query.kind != ASTDropQuery::Kind::Drop && query.kind != ASTDropQuery::Kind::Truncate)
        return {};

    const auto & database_name = query.getDatabase();
    auto ddl_guard = DatabaseCatalog::instance().getDDLGuard(database_name, "", nullptr);

    database = tryGetDatabase(database_name, query.if_exists);
    if (!database)
        return {};

    bool drop = query.kind == ASTDropQuery::Kind::Drop;
    bool truncate = query.kind == ASTDropQuery::Kind::Truncate;

    getContext()->checkAccess(AccessType::DROP_DATABASE, database_name);

    auto * const db_replicated = dynamic_cast<DatabaseReplicated *>(database.get());
    if (truncate && db_replicated)
        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "TRUNCATE DATABASE is not implemented for replicated databases");

    if (query.kind == ASTDropQuery::Kind::Detach && query.permanently)
        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "DETACH PERMANENTLY is not implemented for databases");

    if (query.if_empty)
        throw Exception(ErrorCodes::NOT_IMPLEMENTED, "DROP IF EMPTY is not implemented for databases");

    if (!truncate && database->hasReplicationThread())
        database->stopReplication();

    if (database->shouldBeEmptyOnDetach())
    {
        /// Cancel restarting replicas in that database, wait for remaining RESTART queries to finish.
        /// So it will not startup tables concurrently with the flushAndPrepareForShutdown call below.
        auto restart_replica_lock = DatabaseCatalog::instance().getLockForDropDatabase(database_name);

        ASTDropQuery query_for_table;
        query_for_table.kind = query.kind;
        // For truncate operation on database, drop the tables
        if (truncate)
            query_for_table.kind = query.has_tables ? ASTDropQuery::Kind::Truncate : ASTDropQuery::Kind::Drop;
        if (database->getDisk()->isReadOnly())
            query_for_table.kind = ASTDropQuery::Detach;
        query_for_table.if_exists = true;
        query_for_table.if_empty = false;
        query_for_table.setDatabase(database_name);
        query_for_table.sync = query.sync;

        /// If we have a TRUNCATE TABLES .. LIKE, we should not truncate all tables,
        /// the logic regarding finding suitable tables is a bit below
        if (!truncate || !query.has_tables || query.like.empty())
        {
            /// Flush should not be done if shouldBeEmptyOnDetach() == false,
            /// since in this case getTablesIterator() may do some additional work,
            /// see DatabaseMaterialized...SQL::getTablesIterator()
            auto table_context = Context::createCopy(getContext());
            table_context->setInternalQuery(true);