**Describe what's wrong**

It's not possible to initialize aggregation function from nullable types.

**Does it reproduce on recent release?**

Yes, 
ClickHouse version 21.10

```
SELECT initializeAggregation('uniqExactState', toNullable(''))


0 rows in set. Elapsed: 0.003 sec.

Received exception from server (version 21.10.1):
Code: 43. DB::Exception: Received from localhost:9000. DB::Exception: Nested type AggregateFunction(uniqExact, String) cannot be inside Nullable type: While processing initializeAggregation('uniqExactState', toNullable('')). (ILLEGAL_TYPE_OF_ARGUMENT)


SELECT initializeAggregation('uniqExactState', toNullable(1))


Received exception from server (version 21.10.1):
Code: 43. DB::Exception: Received from localhost:9000. DB::Exception: Nested type AggregateFunction(uniqExact, UInt8) cannot be inside Nullable type: While processing initializeAggregation('uniqExactState', toNullable(1)). (ILLEGAL_TYPE_OF_ARGUMENT)
```


**Expected behavior**

It should be possible to initialize aggregation function from nullable types.


**Additional context**

WA

```
SELECT arrayReduce('uniqExactState', [toNullable('')])

Query id: 29fc6760-78be-4f28-be5f-f1bbe12f04fc

┌─arrayReduce('uniqExactState', array(toNullable('')))─┐
│ 2���V���嵶����                                                │
└──────────────────────────────────────────────────────┘
```

{
    if (arguments.size() < 2)
        throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
            + toString(arguments.size()) + ", should be at least 2.",
            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
    const ColumnConst * aggregate_function_name_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
    if (!aggregate_function_name_column)
        throw Exception("First argument for function " + getName() + " must be constant string: name of aggregate function.",
            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
    DataTypes argument_types(arguments.size() - 1);
    for (size_t i = 1, size = arguments.size(); i < size; ++i)
    {
        argument_types[i - 1] = arguments[i].type;
    }
    if (!aggregate_function)
    {
        String aggregate_function_name_with_params = aggregate_function_name_column->getValue<String>();
        if (aggregate_function_name_with_params.empty())
            throw Exception("First argument for function " + getName() + " (name of aggregate function) cannot be empty.",
                ErrorCodes::BAD_ARGUMENTS);
        String aggregate_function_name;
        Array params_row;
        getAggregateFunctionNameAndParametersArray(aggregate_function_name_with_params,
                                                   aggregate_function_name, params_row, "function " + getName(), getContext());
        AggregateFunctionProperties properties;
        aggregate_function = AggregateFunctionFactory::instance().get(aggregate_function_name, argument_types, params_row, properties);
    }
    return aggregate_function->getReturnType();
}
ColumnPtr FunctionInitializeAggregation::executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const