Method createObjectWrapper

src/Functions/FunctionsConversion.cpp:1341–1398

}

FunctionCast::WrapperType FunctionCast::createObjectWrapper(const DataTypePtr & from_type, const DataTypeObject * to_object, bool requested_result_is_nullable) const
{
    if (checkAndGetDataType<DataTypeString>(from_type.get()))
    {
        return [this, requested_result_is_nullable](ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const ColumnNullable * nullable_source, size_t input_rows_count)
        {
            if (requested_result_is_nullable && cast_type == CastType::accurateOrNull)
                return ConvertImplGenericFromString<false>::execute(arguments, makeNullable(result_type), nullable_source, input_rows_count, settings);

            return ConvertImplGenericFromString<true>::execute(arguments, result_type, nullable_source, input_rows_count, settings);
        };
    }

    /// Cast Tuple/Object/Map/JSON to JSON type through serializing into JSON string and parsing back into JSON column.
    /// Potentially we can do smarter conversion Tuple -> JSON with type preservation, but it's questionable how exactly Tuple should be
    /// converted to JSON (for example, should we recursively convert nested Array(Tuple) to Array(JSON) or not, should we infer types from String fields, etc).
    /// Proper implementation of a conversion between 2 different JSON types is really complex, because different JSON types
    /// can have different parameters:
    /// - set of typed paths
    /// - set of skip rules
    /// - max_dynamic_paths/max_dynamic_types parameters
    /// Also max_dynamic_paths/max_dynamic_types parameters of nested JSON types depend on current max_dynamic_paths/max_dynamic_types,
    /// so if these parameters are changed, we have to recursively find all nested JSON types and change their parameters as well.
    /// It's all complicates the implementation and last attempt to implement it led to several bugs.
    /// So for now let's perform this conversion through cast to String and parsing new JSON back from it.
    /// It's not effective, but 100% accurate.
    if (checkAndGetDataType<DataTypeTuple>(from_type.get())
        || checkAndGetDataType<DataTypeMap>(from_type.get()) || checkAndGetDataType<DataTypeObject>(from_type.get()))
    {
        return [this, requested_result_is_nullable](ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const ColumnNullable * nullable_source, size_t input_rows_count)
        {
            auto json_string = ColumnString::create();
            ColumnStringHelpers::WriteHelper<ColumnString> write_helper(assert_cast<ColumnString &>(*json_string), input_rows_count);
            auto & write_buffer = write_helper.getWriteBuffer();
            FormatSettings format_settings = settings.format_settings;
            auto serialization = arguments[0].type->getDefaultSerialization();
            format_settings.json.quote_64bit_integers = false;
            for (size_t i = 0; i < input_rows_count; ++i)
            {
                serialization->serializeTextJSON(*arguments[0].column, i, write_buffer, format_settings);
                write_helper.finishRow();
            }
            write_helper.finalize();

            ColumnsWithTypeAndName args_with_json_string = {ColumnWithTypeAndName(json_string->getPtr(), std::make_shared<DataTypeString>(), "")};
            if (requested_result_is_nullable && cast_type == CastType::accurateOrNull)
                return ConvertImplGenericFromString<false>::execute(args_with_json_string, makeNullable(result_type), nullable_source, input_rows_count, settings);

            return ConvertImplGenericFromString<true>::execute(args_with_json_string, result_type, nullable_source, input_rows_count, settings);
        };
    }

    throw Exception(
        ErrorCodes::TYPE_MISMATCH,
        "Cast to {} can be performed only from String/Map/Object/Tuple/JSON. Got: {}",
        to_object->getSchemaFormatString(),
        from_type->getName());
}