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




return result_node;
    }
    auto cloned_node = node->clone();
    if (func && inverse_relations.find(func->name) != inverse_relations.cend())
    {
        if (need_inversion)
        {
            cloned_node->as<ASTFunction>()->name = inverse_relations.at(func->name);
        }
        return cloned_node;
    }
    return need_inversion ? makeASTFunction("not", cloned_node) : cloned_node;
}
inline bool Range::equals(const Field & lhs, const Field & rhs) { return applyVisitor(FieldVisitorAccurateEquals(), lhs, rhs); }
inline bool Range::less(const Field & lhs, const Field & rhs) { return applyVisitor(FieldVisitorAccurateLess(), lhs, rhs); }
/** Calculate expressions, that depend only on constants.
  * For index to work when something like "WHERE Date = toDate(now())" is written.
  */
Block KeyCondition::getBlockWithConstants(
    const ASTPtr & query, const TreeRewriterResultPtr & syntax_analyzer_result, const Context & context)
{
    Block result
    {
        { DataTypeUInt8().createColumnConstWithDefaultValue(1), std::make_shared<DataTypeUInt8>(), "_dummy" }
    };
    const auto expr_for_constant_folding = ExpressionAnalyzer(query, syntax_analyzer_result, context).getConstActions();
    expr_for_constant_folding->execute(result);
    return result;
}
KeyCondition::KeyCondition(