Method dropInnerTableIfAny

src/Storages/StorageMaterializedView.cpp:526–554

}

void StorageMaterializedView::dropInnerTableIfAny(bool sync, ContextPtr local_context)
{
    if (!has_inner_table)
        return;

    std::vector<StorageID> to_drop = {getTargetTableId()};
    if (!fixed_uuid)
        to_drop.push_back(StorageID(to_drop[0].getDatabaseName(), ".tmp" + to_drop[0].getTableName()));

    for (const StorageID & inner_table_id : to_drop)
    {
        /// We will use `sync` argument when this function is called from a DROP query
        /// and will ignore database_atomic_wait_for_drop_and_detach_synchronously when it's called from drop task.
        /// See the comment in StorageMaterializedView::drop.
        ///
        /// DDL queries with StorageMaterializedView are fundamentally broken: we can't lock DDLGuard
        /// here because DDLGuards must be locked in order of increasing table name (to avoid deadlocks),
        /// while the inner table name is almost always less than the MV name.
        /// So we just don't lock it. It's mostly ok because DatabaseReplicatedDDLWorker doesn't
        /// execute queries concurrently, but presumably there are other race conditions
        /// (I'm not the author of this code and don't know for sure, just commenting).
        /// (Why not reverse DDLGuard locking order everywhere? Because in another place we lock
        /// DDLGuard for table "<name><suffix>" while holding DDLGuard for table "<name>".)
        auto table_exists = DatabaseCatalog::instance().tryGetTable(inner_table_id, getContext()) != nullptr;
        if (table_exists)
            InterpreterDropQuery::executeDropQuery(ASTDropQuery::Kind::Drop, getContext(), local_context, inner_table_id,
                                                   sync, /* ignore_sync_setting */ true, /*need_ddl_guard*/ false);
    }
}

void StorageMaterializedView::truncate(const ASTPtr &, const StorageMetadataPtr &, ContextPtr local_context, TableExclusiveLockHolder &)
{