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?

command,
            configuration.command_arguments,
            std::move(shell_input_pipes),
            result_block,
            context,
            shell_command_source_configuration);
        QueryPipeline pipeline(std::move(pipe));
        PullingPipelineExecutor executor(pipeline);
        auto result_column = result_type->createColumn();
        result_column->reserve(input_rows_count);
        Block block;
        while (executor.pull(block))
        {
            const auto & result_column_to_add = *block.safeGetByPosition(0).column;
            result_column->insertRangeFrom(result_column_to_add, 0, result_column_to_add.size());
        }
        size_t result_column_size = result_column->size();
        if (result_column_size != input_rows_count)
            throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
                "Function {}: wrong result, expected {} row(s), actual {}",
                quoteString(getName()),
                input_rows_count,
                result_column_size);
        return result_column;
    }
private:
    ExternalUserDefinedExecutableFunctionsLoader::UserDefinedExecutableFunctionPtr executable_function;
    ContextPtr context;
};
UserDefinedExecutableFunctionFactory & UserDefinedExecutableFunctionFactory::instance()