**Describe the bug**

`sumIf` returns incorrect results in some cases with Nullable arguments.

**How to reproduce**

* Which ClickHouse server version to use
Latest master/arcadia version

* Queries to run that lead to unexpected result
```sql
:) select sumIf(toFloat64OrZero(b), a = 0) as r1, sumIf(cast(b as Float), a = 0) as r2, sum(if(a = 0, toFloat64OrZero(b), 0)) as r3 from (select arrayJoin([1, 2, 3, NULL]) as a, toNullable('10.0') as b)

SELECT
    sumIf(toFloat64OrZero(b), a = 0) AS r1,
    sumIf(CAST(b, 'Float'), a = 0) AS r2,
    sum(if(a = 0, toFloat64OrZero(b), 0)) AS r3
FROM
(
    SELECT
        arrayJoin([1, 2, 3, NULL]) AS a,
        toNullable('10.0') AS b
)

Query id: 2e4e320d-e52a-4514-bc6f-118485558191

┌─r1─┬─r2─┬─r3─┐
│ 10 │  0 │  0 │
└────┴────┴────┘
```
**Expected behavior**

All results are 0.

**Additional context**

It breaks when null values in Nullable column are compared with `assumeNotNull` from this column.
It also only breaks when first argument is Nullable too.


if (std::any_of(type_without_low_cardinality.begin(), type_without_low_cardinality.end(),
        [](const auto & type) { return type->isNullable(); }))
    {
        AggregateFunctionCombinatorPtr combinator = AggregateFunctionCombinatorFactory::instance().tryFindSuffix("Null");
        if (!combinator)
            throw Exception("Logical error: cannot find aggregate function combinator to apply a function to Nullable arguments.",
                ErrorCodes::LOGICAL_ERROR);
        DataTypes nested_types = combinator->transformArguments(type_without_low_cardinality);
        Array nested_parameters = combinator->transformParameters(parameters);
        bool has_null_arguments = std::any_of(type_without_low_cardinality.begin(), type_without_low_cardinality.end(),
            [](const auto & type) { return type->onlyNull(); });
        AggregateFunctionPtr nested_function = getImpl(
            name, nested_types, nested_parameters, out_properties, has_null_arguments);
        
        
        
        
        
        if (!nested_function || !nested_function->isOnlyWindowFunction())
        {
            return combinator->transformAggregateFunction(nested_function,
                out_properties, type_without_low_cardinality, parameters);
        }
    }
    auto with_original_arguments = getImpl(name, type_without_low_cardinality, parameters, out_properties, false);
    if (!with_original_arguments)
        throw Exception("Logical error: AggregateFunctionFactory returned nullptr", ErrorCodes::LOGICAL_ERROR);
    return with_original_arguments;
}
AggregateFunctionPtr AggregateFunctionFactory::getImpl(