The function should return an estimate of uncompressed byte size of its arguments in memory.
E.g. for UInt32 argument it will return constant 4, for String argument - the string length + 9.
The function can take multiple arguments. The typical application is `byteSize(*)`.

**Use case**
Suppose you have a service that stores data for multiple clients in one table. Users will pay per data volume. So, you need to implement accounting of users data volume. The function will allow to calculate the data size on per-row basis.
{
        return std::make_shared<FunctionByteSize>();
    }
    String getName() const override { return name; }
    bool useDefaultImplementationForNulls() const override { return false; }
    bool useDefaultImplementationForLowCardinalityColumns() const override { return false; }
    bool isVariadic() const override { return true; }
    size_t getNumberOfArguments() const override { return 0; }
    DataTypePtr getReturnTypeImpl(const DataTypes & ) const override
    {
        return std::make_shared<DataTypeUInt64>();
    }
    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
    {
        auto result_col = ColumnUInt64::create(input_rows_count);
        auto & vec_res = result_col->getData();
        size_t size = arguments.size();
        for (size_t i = 0; i < size; ++i)
        {
            const IColumn * column = arguments[i].column.get();
            const IDataType * data_type = arguments[i].type.get();
            ResultHolder res(vec_res, i == 0);
            byteSizeOne(data_type, column, res);
        }
        return result_col;
    }
private:
    static void byteSizeOne(const IDataType * data_type, const IColumn * column, ResultHolder & res)