When I'm executing a UDF function, a `null value` input to the script is received as `0`(for numbers) and `empty string` (for strings). 

The UDF definition like this
```
<function>
    <type>executable</type>
    <name>some_function_name</name>
    <return_name>result</return_name>
    <return_type>String</return_type>
    <argument>
        <type>Nullable(Int32)</type>
        <name>argument_1</name>
    </argument>
    <format>JSONEachRow</format>
    <command>some_function.py</command>
</function>
```
And the script file link this (Here whatever input I got I'm logging it to a file.)
```
#!/usr/bin/python3

import sys
import json

def write_to_file(line):
	with open("/tmp/input.log",'a') as fw:
		fw.write(str(line))

if __name__ == '__main__':
    for line in sys.stdin:
        # Writing log
        write_to_file(line)

        result = {"result":str(line)}
        print(json.dumps(result))
        sys.stdout.flush()
```

I got the below results 
```
clickhouse-client --query="select value, some_function_name(value) from (SELECT 1 as value UNION ALL SELECT NULL UNION ALL SELECT 0) FORMAT Vertical"  --input_format_tsv_empty_as_default=1

Row 1:
──────
value:                     1
some_function_name(value): {"argument_1":1}


Row 2:
──────
value:                     ᴺᵁᴸᴸ
some_function_name(value): ᴺᵁᴸᴸ

Row 3:
──────
value:                     0
some_function_name(value): {"argument_1":0}

```
Here, the result for `Row 2` should be `{"argument_1":NULL}` but it's `NULL`.

And the log I got  for inputs as below
```
{"argument_1":1}
{"argument_1":0}
{"argument_1":0}
```

So, is there any option to get the `NULL` value as `NULL` to the input script?

{
public:
    explicit UserDefinedFunction(
        ExternalUserDefinedExecutableFunctionsLoader::UserDefinedExecutableFunctionPtr executable_function_,
        ContextPtr context_)
        : executable_function(std::move(executable_function_))
        , context(context_)
    {
    }
    String getName() const override { return executable_function->getConfiguration().name; }
    bool isVariadic() const override { return false; }
    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & ) const override { return true; }
    size_t getNumberOfArguments() const override { return executable_function->getConfiguration().arguments.size(); }
    bool useDefaultImplementationForConstants() const override { return true; }
    bool useDefaultImplementationForNulls() const override { return true; }
    bool isDeterministic() const override { return false; }
    bool isDeterministicInScopeOfQuery() const override { return false; }
    DataTypePtr getReturnTypeImpl(const DataTypes &) const override
    {
        const auto & configuration = executable_function->getConfiguration();
        return configuration.result_type;
    }
    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override