**Describe the bug**

A combination of `use_join_nulls=1`, a `Nullable(enum)` column, `OUTER JOIN`, and `toString()` may throw an exception while generating a result.

**Does it reproduce on recent release?**

This happens on 21.6.3 stable.

**How to reproduce**

With the following setup:

```sql
CREATE TABLE a (
  key  String
) ENGINE=MergeTree ORDER BY key;

CREATE TABLE b (
  key  String,
  data Nullable(Enum16('a'=1, 'b'=2))
) ENGINE=MergeTree ORDER BY key;

INSERT INTO a VALUES('x');
INSERT INTO a VALUES('y');

INSERT INTO b VALUES('x', 'a');
```

This query appears to work correctly:
```
SELECT
	key, data
FROM a
ANY LEFT OUTER JOIN b USING (key)
FORMAT JSONCompact
SETTINGS join_use_nulls = 1;
```

```
{
        "meta":
        [
                {
                        "name": "key",
                        "type": "String"
                },
                {
                        "name": "data",
                        "type": "Nullable(Enum16('a' = 1, 'b' = 2))"
                }
        ],
        "data":
        [
                ["y", null],                                                                                                                                                                                                
                ["x", "a"]                                                                                                                                                                                                     
        ],
        "rows": 2,
        "statistics":
        {
                "elapsed": 0.002955967,
                "rows_read": 3,
                "bytes_read": 33
        }
}
```

But it throws an exception when `toString()` is applied to the joined column:

```sql
SELECT
	key, toString(data)
FROM a
LEFT OUTER JOIN b USING (key)
FORMAT JSONCompact
SETTINGS join_use_nulls = 1;
```

```
{
        "meta":
        [
                {
                        "name": "key",
                        "type": "String"
                },
                {
                        "name": "toString(data)",
                        "type": "Nullable(String)"
                }
        ],

        "data":
        [
                ["x", "a"]                                                                                                                                                                                                      Progress: 0.00 rows, 0.00 B (0.00 rows/s., 0.00 B/s.)
1 rows in set. Elapsed: 0.003 sec.

Received exception from server (version 21.6.3):
Code: 36. DB::Exception: Received from localhost:9000. DB::Exception: Unexpected value 0 in enum: while executing 'FUNCTION toString(data :: 1) -> toString(data) Nullable(String) : 2'.
```

**Expected behavior**

It produces a string `NULL` without throwing an exception.
if constexpr (std::is_same_v<A, FunctionArgumentDescriptor>)
                {
                    if (a.argument_name)
                        result += "'" + std::string(a.argument_name) + "' : ";
                    if (a.expected_type_description)
                        result += a.expected_type_description;
                }
                else if constexpr (std::is_same_v<A, ColumnWithTypeAndName>)
                    result += a.type->getName();
                result += sep;
            }
            if (!args.empty())
                result.erase(result.end() - sep.length(), result.end());
            return result;
        };
        throw Exception("Incorrect number of arguments for function " + func.getName()
                        + " provided " + std::to_string(arguments.size())
                        + (!arguments.empty() ? " (" + join_argument_types(arguments) + ")" : String{})
                        + ", expected " + std::to_string(mandatory_args.size())
                        + (!optional_args.empty() ? " to " + std::to_string(mandatory_args.size() + optional_args.size()) : "")
                        + " (" + join_argument_types(mandatory_args)
                        + (!optional_args.empty() ? ", [" + join_argument_types(optional_args) + "]" : "")
                        + ")",
                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
    }
    validateArgumentsImpl(func, arguments, 0, mandatory_args);
    if (!optional_args.empty())
        validateArgumentsImpl(func, arguments, mandatory_args.size(), optional_args);
}
std::pair<std::vector<const IColumn *>, const ColumnArray::Offset *>