Method checkMutationIsPossible

src/Storages/MergeTree/MergeTreeData.cpp:5046–5143

}

void MergeTreeData::checkMutationIsPossible(const MutationCommands & commands, const Settings & /*settings*/) const
{
    for (const auto & disk : getDisks())
        if (!disk->supportsHardLinks())
            throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, "Mutations are not supported for immutable disk '{}'", disk->getName());

    /// Reject mutations that bypass UK dedup: DELETE/UPDATE rewrite rows;
    /// MATERIALIZE COLUMN / CLEAR COLUMN (the latter serialized as
    /// `DROP_COLUMN` with `clear=true`) rewrite stored bytes.
    if (auto uk_metadata = getInMemoryMetadataPtr(getContext(), false); uk_metadata->hasUniqueKey())
    {
        const auto & uk_column_names = uk_metadata->getUniqueKeyColumns();
        auto is_uk_column = [&](const String & column)
        {
            return std::find(uk_column_names.begin(), uk_column_names.end(), column) != uk_column_names.end();
        };

        for (const auto & command : commands)
        {
            if (command.type == MutationCommand::DELETE || command.type == MutationCommand::UPDATE)
                throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
                    "ALTER DELETE / ALTER UPDATE is not supported on tables with UNIQUE KEY");

            /// MATERIALIZE TTL rewrites parts to apply expiration, bypassing the UNIQUE KEY
            /// dedup path (like MATERIALIZE COLUMN below) — and TTL is unsupported anyway
            /// while merges are disabled. Reject so an ATTACH-loaded UK+TTL table cannot
            /// materialize it.
            if (command.type == MutationCommand::MATERIALIZE_TTL)
                throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
                    "ALTER TABLE ... MATERIALIZE TTL is not supported on tables with UNIQUE KEY");

            if (command.type == MutationCommand::MATERIALIZE_COLUMN && is_uk_column(command.column_name))
                throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
                    "ALTER TABLE ... MATERIALIZE COLUMN `{}` is not supported: the column is part of the UNIQUE KEY, "
                    "and MATERIALIZE would rewrite stored values without going through UNIQUE KEY dedup, "
                    "producing duplicate live keys. UNIQUE KEY columns: ({}).",
                    command.column_name, fmt::join(uk_column_names, ", "));

            if (command.type == MutationCommand::DROP_COLUMN && command.clear && is_uk_column(command.column_name))
                throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
                    "ALTER TABLE ... CLEAR COLUMN `{}` is not supported: the column is part of the UNIQUE KEY, "
                    "and CLEAR would rewrite stored values without going through UNIQUE KEY dedup, "
                    "producing duplicate live keys. UNIQUE KEY columns: ({}).",
                    command.column_name, fmt::join(uk_column_names, ", "));

            /// These commands rebuild whole parts (the full read+rewrite mutation path) and
            /// drop the delete_bitmap_*.rbm sidecars, silently resurrecting deleted rows once
            /// DELETE lands. MATERIALIZE INDEX/STATISTICS/PROJECTION reach the same path via
            /// MutateAllPartColumnsTask for compact or non-full parts (which only hardlinks
            /// checksummed entries, not the sidecars). Reject the whole destructive-rewrite family.
            if (command.type == MutationCommand::REWRITE_PARTS
                || command.type == MutationCommand::APPLY_DELETED_MASK
                || command.type == MutationCommand::APPLY_PATCHES
                || command.type == MutationCommand::MATERIALIZE_INDEX
                || command.type == MutationCommand::MATERIALIZE_STATISTICS
                || command.type == MutationCommand::MATERIALIZE_PROJECTION)
                throw Exception(ErrorCodes::SUPPORT_IS_DISABLED,
                    "ALTER TABLE ... {} is not supported on tables with UNIQUE KEY",