**Describe the unexpected behaviour**

Not sure if it is a bug but we encounter a very strange issue when using the same field 2 times in a where clause.
Basically : field = <> and toYear(field)= <>

**How to reproduce**
* Clickhouse 20.5.2.7


Create table statement :
```
DROP TABLE IF EXISTS datasources.cal_pace_strange2;
CREATE TABLE datasources.cal_pace_strange2
(
    `htl_id` UInt32,
    `stay_date` Date,
    `snpdate` Date,
    `leadtime` String,
    `los` String,
    `mkt_id` String,
    `sob_id` String,
    `res_status_id` String,
    `rt_id` String,
    `cur` String,
    `rns` Decimal(9, 4),
    `arrivals` Decimal(9, 4),
    `departures` Decimal(9, 4),
    `adults` Decimal(9, 4),
    `children` Decimal(9, 4),
    `rm_rev` Decimal(18, 10),
    `fd_rev` Decimal(18, 10),
    `oth_rev` Decimal(18, 10),
    `tot_rev` Decimal(18, 10)

)
    ENGINE = MergeTree()
        PARTITION BY toYYYYMM(snpdate)
        ORDER BY (htl_id, stay_date, snpdate)
        SETTINGS index_granularity = 8192;
```

Load the data using the attached SQL inserts.

[data_bug_clickhouse.txt](https://github.com/ClickHouse/ClickHouse/files/4903808/data_bug_clickhouse.txt)


This query returns 0 results :

`select * from cal_pace_strange2 where snpdate='2020-06-09' and htl_id=66 and stay_date='2020-10-02' and toYear(stay_date) = 2020;`

This one return the correct results :

`select * from cal_pace_strange2 where snpdate='2020-06-09' and htl_id=66 and stay_date='2020-10-02'`

Same behavior occurs in 20.4.3 and 20.4.4

Expected behavior :

Both queries should return the same results.




* Instead, we can qualify only functions that do not transform the range (for example rounding),
          * which while not strictly monotonic, are monotonic everywhere on the input range.
          */
        const auto & action = a.argument_names;
        if (a.type == ExpressionAction::Type::APPLY_FUNCTION && action.size() == 1 && a.argument_names[0] == expr_name)
        {
            if (!a.function_base->hasInformationAboutMonotonicity())
                return false;
            
            IFunction::Monotonicity monotonicity = a.function_base->getMonotonicityForRange(*out_type, Field(), Field());
            if (!monotonicity.is_always_monotonic)
                return false;
            
            out_value = applyFunctionForField(a.function_base, out_type, out_value);
            out_type = a.function_base->getReturnType();
            expr_name = a.result_name;
            
            auto it = key_columns.find(expr_name);
            if (key_columns.end() != it)
            {
                out_key_column_num = it->second;
                out_key_column_type = sample_block.getByName(it->first).type;
                found_transformation = true;
                break;
            }
        }
    }
    return found_transformation;
}
bool KeyCondition::tryPrepareSetIndex(