This function is strange. Looks like the implementation is of low quality.

```
bool isDeterministic() const override { return false; }
bool isDeterministicInScopeOfQuery() const override { return false; }
```
Why it is not deterministic? Missing a comment.

```
String convertToJson(const PODArray<String> & variant_names, const Variants & variants)
{
    FormatSettings settings;

    WriteBufferFromOwnString buf;

    writeCString("{\"data\":[", buf);
    for (size_t i = 0; i < variants.size(); ++i)
    {
        writeCString("{\"variant_name\":", buf);
        writeJSONString(variant_names[i], buf, settings);
        writeCString(",\"x\":", buf);
        writeText(variants[i].x, buf);
        writeCString(",\"y\":", buf);
        writeText(variants[i].y, buf);
        writeCString(",\"beats_control\":", buf);
        writeText(variants[i].beats_control, buf);
        writeCString(",\"to_be_best\":", buf);
        writeText(variants[i].best, buf);
        writeCString("}", buf);
        if (i != variant_names.size() -1)
            writeCString(",", buf);
    }
    writeCString("]}", buf);

    return buf.str();
}
```
It returns unstructured data? :scream: 

As first step we can remove documentation for this function.
CC @nikitamikhaylov 
bool isDeterministicInScopeOfQuery() const override { return false; }
    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & ) const override { return true; }
    size_t getNumberOfArguments() const override { return 5; }
    DataTypePtr getReturnTypeImpl(const DataTypes &) const override
    {
        return std::make_shared<DataTypeString>();
    }
    static bool toFloat64(const ColumnConst * col_const_arr, PODArray<Float64> & output)
    {
        Array src_arr = col_const_arr->getValue<Array>();
        for (size_t i = 0, size = src_arr.size(); i < size; ++i)
        {
            switch (src_arr[i].getType())
            {
                case Field::Types::Int64:
                    output.push_back(static_cast<Float64>(src_arr[i].get<const Int64 &>()));
                    break;
                case Field::Types::UInt64:
                    output.push_back(static_cast<Float64>(src_arr[i].get<const UInt64 &>()));
                    break;
                case Field::Types::Float64:
                    output.push_back(src_arr[i].get<const Float64 &>());
                    break;
                default:
                    return false;
            }
        }
        return true;
    }
    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override