**How to reproduce**

Query:
```sql
select
	x,
	min(x) as lower,
	max(x)+1 as upper,
	upper-lower as range
from (select arrayJoin([1, 2]) as x)
group by x
with rollup;
```

## 20.4.6
```
┌─x─┬─lower─┬─upper─┬─range─┐
│ 1 │     1 │     2 │     1 │
│ 2 │     2 │     3 │     1 │
└───┴───────┴───────┴───────┘
┌─x─┬─lower─┬─upper─┬─range─┐
│ 0 │     1 │     3 │     2 │
└───┴───────┴───────┴───────┘
```
Summary looks correct.

## 20.9.3
```
┌─x─┬─lower─┬─upper─┬─range─┐
│ 1 │     1 │     2 │     1 │
│ 2 │     2 │     3 │     1 │
└───┴───────┴───────┴───────┘
┌─x─┬─lower─┬─upper─┬─range─┐
│ 0 │     0 │     3 │     2 │
└───┴───────┴───────┴───────┘
```
`lower` is wrong - the minimum should be 1. However, all other "derived" values are correct. For example `range` correctly shows up as 2, even though table would wrongly imply that `upper-lower==3-0==3`.
Note that I only tested 20.4.6 and 20.9.3, so the regression might have been anywhere in between.

## 20.10.2
```
┌─x─┬─lower─┬─upper─┬─range─┐
│ 1 │     1 │     2 │     1 │
│ 2 │     2 │     3 │     1 │
└───┴───────┴───────┴───────┘
┌─x─┬─lower─┬─upper─┬─range─┐
│ 0 │     0 │     1 │     1 │
└───┴───────┴───────┴───────┘
```
All values are wrong.
if (function->arguments->children.size() < 2)
                {
                    ++i;
                    continue;
                }
                const auto * dict_name_ast = function->arguments->children[0]->as<ASTLiteral>();
                const auto * attr_name_ast = function->arguments->children[1]->as<ASTLiteral>();
                if (!dict_name_ast || !attr_name_ast)
                {
                    ++i;
                    continue;
                }
                const auto & dict_name = dict_name_ast->value.safeGet<String>();
                const auto & attr_name = attr_name_ast->value.safeGet<String>();
                String resolved_name = DatabaseCatalog::instance().resolveDictionaryName(dict_name);
                const auto & dict_ptr = context.getExternalDictionariesLoader().getDictionary(resolved_name);
                if (!dict_ptr->isInjective(attr_name))
                {
                    ++i;
                    continue;
                }
            }
            else if (!function_factory.get(function->name, context)->isInjective({}))
            {
                ++i;
                continue;
            }
            
            auto args_ast = function->arguments;
            /** remove function call and take a step back to ensure