Function createTypeFromNode

src/DataTypes/ObjectUtils.cpp:652–750

Creates data type and column from tree of subcolumns.

/// Creates data type and column from tree of subcolumns.
ColumnWithTypeAndDimensions createTypeFromNode(const Node & node)
{
    auto collect_tuple_elemets = [](const auto & children)
    {
        if (children.empty())
            throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot create type from empty Tuple or Nested node");

        std::vector<std::tuple<String, ColumnWithTypeAndDimensions>> tuple_elements;
        tuple_elements.reserve(children.size());
        for (const auto & [name, child] : children)
        {
            assert(child);
            auto column = createTypeFromNode(*child);
            tuple_elements.emplace_back(name, std::move(column));
        }

        /// Sort to always create the same type for the same set of subcolumns.
        std::sort(tuple_elements.begin(), tuple_elements.end(),
            [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); });

        auto tuple_names = extractVector<0>(tuple_elements);
        auto tuple_columns = extractVector<1>(tuple_elements);

        return std::make_tuple(std::move(tuple_names), std::move(tuple_columns));
    };

    if (node.kind == Node::SCALAR)
    {
        return node.data;
    }
    else if (node.kind == Node::NESTED)
    {
        auto [tuple_names, tuple_columns] = collect_tuple_elemets(node.children);

        Columns offsets_columns;
        offsets_columns.reserve(tuple_columns[0].array_dimensions + 1);

        /// If we have a Nested node and child node with anonymous array levels
        /// we need to push a Nested type through all array levels.
        /// Example: { "k1": [[{"k2": 1, "k3": 2}] } should be parsed as
        /// `k1 Array(Nested(k2 Int, k3 Int))` and k1 is marked as Nested
        /// and `k2` and `k3` has anonymous_array_level = 1 in that case.

        const auto & current_array = assert_cast<const ColumnArray &>(*node.data.column);
        offsets_columns.push_back(current_array.getOffsetsPtr());

        auto first_column = tuple_columns[0].column;
        for (size_t i = 0; i < tuple_columns[0].array_dimensions; ++i)
        {
            const auto & column_array = assert_cast<const ColumnArray &>(*first_column);
            offsets_columns.push_back(column_array.getOffsetsPtr());
            first_column = column_array.getDataPtr();
        }

        size_t num_elements = tuple_columns.size();
        Columns tuple_elements_columns(num_elements);
        DataTypes tuple_elements_types(num_elements);