Function recursivelyConvertDynamicColumnToTuple

src/DataTypes/ObjectUtils.cpp:175–238

}

static std::pair<ColumnPtr, DataTypePtr> recursivelyConvertDynamicColumnToTuple(
    const ColumnPtr & column, const DataTypePtr & type)
{
    if (!type->hasDynamicSubcolumns())
        return {column, type};

    if (const auto * type_object = typeid_cast<const DataTypeObject *>(type.get()))
    {
        const auto & column_object = assert_cast<const ColumnObject &>(*column);
        return convertObjectColumnToTuple(column_object, *type_object);
    }

    if (const auto * type_array = typeid_cast<const DataTypeArray *>(type.get()))
    {
        const auto & column_array = assert_cast<const ColumnArray &>(*column);
        auto [new_column, new_type] = recursivelyConvertDynamicColumnToTuple(
            column_array.getDataPtr(), type_array->getNestedType());

        return
        {
            ColumnArray::create(new_column, column_array.getOffsetsPtr()),
            std::make_shared<DataTypeArray>(std::move(new_type)),
        };
    }

    if (const auto * type_map = typeid_cast<const DataTypeMap *>(type.get()))
    {
        const auto & column_map = assert_cast<const ColumnMap &>(*column);
        auto [new_column, new_type] = recursivelyConvertDynamicColumnToTuple(
            column_map.getNestedColumnPtr(), type_map->getNestedType());

        return
        {
            ColumnMap::create(new_column),
            std::make_shared<DataTypeMap>(std::move(new_type)),
        };
    }

    if (const auto * type_tuple = typeid_cast<const DataTypeTuple *>(type.get()))
    {
        const auto & tuple_columns = assert_cast<const ColumnTuple &>(*column).getColumns();
        const auto & tuple_types = type_tuple->getElements();

        assert(tuple_columns.size() == tuple_types.size());
        const size_t tuple_size = tuple_types.size();

        Columns new_tuple_columns(tuple_size);
        DataTypes new_tuple_types(tuple_size);

        for (size_t i = 0; i < tuple_size; ++i)
        {
            std::tie(new_tuple_columns[i], new_tuple_types[i])
                = recursivelyConvertDynamicColumnToTuple(tuple_columns[i], tuple_types[i]);
        }

        return
        {
            ColumnTuple::create(new_tuple_columns),