Function recursiveConvertType

src/DataTypes/recursiveTypeConversions.h:22–55

template <typename FromType>
DataTypePtr recursiveConvertType(const DataTypePtr & type, Fn<DataTypePtr(const FromType &)> auto && func)
{
    if (!type)
        return type;

    if (const auto * from_type = typeid_cast<const FromType *>(type.get()))
        return func(*from_type);

    if (const auto * array_type = typeid_cast<const DataTypeArray *>(type.get()))
        return std::make_shared<DataTypeArray>(recursiveConvertType<FromType>(array_type->getNestedType(), func));

    if (const auto * map_type = typeid_cast<const DataTypeMap *>(type.get()))
        return std::make_shared<DataTypeMap>(recursiveConvertType<FromType>(map_type->getKeyType(), func), recursiveConvertType<FromType>(map_type->getValueType(), func));

    if (const auto * low_cardinality_type = typeid_cast<const DataTypeLowCardinality *>(type.get()))
        return std::make_shared<DataTypeLowCardinality>(recursiveConvertType<FromType>(low_cardinality_type->getDictionaryType(), func));

    if (const auto * nullable_type = typeid_cast<const DataTypeNullable *>(type.get()))
        return std::make_shared<DataTypeNullable>(recursiveConvertType<FromType>(nullable_type->getNestedType(), func));

    if (const auto * tuple_type = typeid_cast<const DataTypeTuple *>(type.get()))
    {
        DataTypes elements = tuple_type->getElements();
        for (auto & element : elements)
            element = recursiveConvertType<FromType>(element, func);

        if (tuple_type->haveExplicitNames())
            return std::make_shared<DataTypeTuple>(elements, tuple_type->getElementNames());
        else
            return std::make_shared<DataTypeTuple>(elements);
    }

    return type;
}

template <typename FromColumn>
ColumnPtr recursiveConvertColumn(const ColumnPtr & column, Fn<ColumnPtr(const FromColumn &)> auto && func)