Method createColumnToVariantWrapper

src/Functions/FunctionsConversion.cpp:1601–1741

}

FunctionCast::WrapperType FunctionCast::createColumnToVariantWrapper(const DataTypePtr & from_type, const DataTypeVariant & to_variant) const
{
    /// We allow converting NULL to Variant(...) as Variant can store NULLs.
    if (from_type->onlyNull())
    {
        return [](ColumnsWithTypeAndName &, const DataTypePtr & result_type, const ColumnNullable *, size_t input_rows_count) -> ColumnPtr
        {
            auto result_column = result_type->createColumn();
            result_column->insertManyDefaults(input_rows_count);
            return result_column;
        };
    }

    auto from_nested_type = removeNullableOrLowCardinalityNullable(from_type);
    auto variant_discr_opt = to_variant.tryGetVariantDiscriminator(from_nested_type->getName());
    /// Cast String to Variant through parsing if it's not Variant(String).
    if (settings.cast_string_to_variant_use_inference && isStringOrFixedString(removeNullable(removeLowCardinality(from_type))) && (!variant_discr_opt || to_variant.getVariants().size() > 1))
        return createStringToVariantWrapper();

    if (!variant_discr_opt)
        throw Exception(ErrorCodes::CANNOT_CONVERT_TYPE, "Cannot convert type {} to {}. Conversion to Variant allowed only for types from this Variant", from_type->getName(), to_variant.getName());

    /// We resolve the destination variant type by name, but two distinct types can share the same name.
    /// AggregateFunction has a hidden state representation (Aggregation vs Window) that is not encoded
    /// in its name, since it is not a user-facing difference but an internal implementation detail.
    /// So when DataTypeVariant is constructed from two AggregateFunction(f, ...) types that differ only
    /// in state representation, its constructor collapses them by name to a single variant type.
    /// If our source column carries the other state representation, we must cast it to the destination
    /// variant type before storing it as a subcolumn, otherwise serialization would interpret the bytes
    /// using the wrong layout and crash.
    const auto & target_variant_type = to_variant.getVariants()[*variant_discr_opt];
    const auto * from_agg_type = typeid_cast<const DataTypeAggregateFunction *>(from_nested_type.get());
    const auto * target_variant_agg_type = typeid_cast<const DataTypeAggregateFunction *>(target_variant_type.get());
    WrapperType to_target_variant_type_cast;
    if (from_agg_type && target_variant_agg_type && from_agg_type->equalsIgnoringVariant(*target_variant_type)
        && !from_nested_type->equals(*target_variant_type))
    {
        to_target_variant_type_cast = prepareUnpackDictionaries(from_nested_type, target_variant_type);
    }

    return [variant_discr = *variant_discr_opt,
            cast_to_variant_type_wrapper = std::move(to_target_variant_type_cast),
            target_variant_type,
            unwrapped_from_type = from_nested_type]
           (ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const ColumnNullable *, size_t) -> ColumnPtr
    {
        const auto & result_variant_type = assert_cast<const DataTypeVariant &>(*result_type);
        const auto & variant_types = result_variant_type.getVariants();

        auto cast_to_variant_type_if_needed = [&](const ColumnPtr & col) -> ColumnPtr
        {
            if (!cast_to_variant_type_wrapper)
                return col;
            ColumnsWithTypeAndName args = {{col, unwrapped_from_type, ""}};
            return cast_to_variant_type_wrapper(args, target_variant_type, nullptr, col->size());
        };

        if (const ColumnNullable * col_nullable = typeid_cast<const ColumnNullable *>(arguments.front().column.get()))