**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.




{
    RPNElement element;
    if (const auto * func = node->as<ASTFunction>())
    {
        if (tryParseLogicalOperatorFromAST(func, element))
        {
            auto & args = func->arguments->children;
            for (size_t i = 0, size = args.size(); i < size; ++i)
            {
                traverseAST(args[i], context, block_with_constants);
                /** The first part of the condition is for the correct support of `and` and `or` functions of arbitrary arity
                  * - in this case `n - 1` elements are added (where `n` is the number of arguments).
                  */
                if (i != 0 || element.function == RPNElement::FUNCTION_NOT)
                    rpn.emplace_back(element);
            }
            return;
        }
    }
    if (!tryParseAtomFromAST(node, context, block_with_constants, element))
    {
        element.function = RPNElement::FUNCTION_UNKNOWN;
    }
    rpn.emplace_back(std::move(element));
}
bool KeyCondition::canConstantBeWrappedByMonotonicFunctions(