Function autoAssignNumberForEnum

src/DataTypes/DataTypeEnum.cpp:258–317

}

static std::vector<UInt8> autoAssignNumberForEnum(const ASTPtr & arguments, bool allow_relative)
{
    Int64 literal_child_assign_num = 1;
    ASTs assign_number_child;
    assign_number_child.reserve(arguments->children.size());
    /// Each rewritten element keeps a flag that tells `mergeEnumTypes` whether its assigned
    /// number is a temporary relative placeholder or an explicit final value.
    std::vector<UInt8> relative_flags;
    if (allow_relative)
        relative_flags.reserve(arguments->children.size());
    bool is_first_child = true;
    size_t assign_count= 0;
    bool leading_implicit = true;

    for (const ASTPtr & child : arguments->children)
    {
        if (child->as<ASTLiteral>())
        {
            assign_count += !is_first_child;
            /// Keep the addition signed and checked: Int64 + size_t would run unsigned (negative
            /// base wraps to a huge UInt64), and a plain signed add overflows near Int64 max.
            Int64 assign_num = 0;
            if (common::addOverflow(literal_child_assign_num, static_cast<Int64>(assign_count), assign_num))
                throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND,
                    "Auto-assigned value for Enum element overflows Int64 (base {} + offset {})",
                    literal_child_assign_num, assign_count);
            ASTPtr func = makeASTOperator("equals", child, make_intrusive<ASTLiteral>(assign_num));
            assign_number_child.emplace_back(func);
            if (allow_relative)
                relative_flags.push_back(leading_implicit);
        }
        else if (child->as<ASTFunction>())
        {
            if (is_first_child)
            {
                const auto literals = getEnumElementLiterals(child);
                const auto * value_literal = literals.value_literal;
                literal_child_assign_num = value_literal->value.safeGet<Int64>();
            }
            assign_number_child.emplace_back(child);
            if (allow_relative)
                relative_flags.push_back(0);
            leading_implicit = false;
        }
        else
            throw Exception(ErrorCodes::UNEXPECTED_AST_STRUCTURE,
                                    "Elements of Enum data type must be of form: "
                                    "'name' = number or 'name', where name is string literal and number is an integer");

        is_first_child = false;
    }

    if (assign_count != 0 && assign_count != arguments->children.size() - 1)
        throw Exception(ErrorCodes::UNEXPECTED_AST_STRUCTURE,
                        "All elements of Enum data type must be of form: "
                        "'name' = number or 'name', where name is string literal and number is an integer");

    arguments->children = assign_number_child;