```sql
version 21.5.1

drop dictionary if exists curs_dict;
drop table if exists curs;

CREATE TABLE curs
(
    `a` UInt64,
    `b` UInt64,
    `e` UInt64,
    `rate` UInt16
)
ENGINE = MergeTree
ORDER BY a

insert into curs 
   select 1, 
   toYYYYMMDDhhmmss(toDateTime('2020-01-01 00:00:00')+number*2) , 
   toYYYYMMDDhhmmss(toDateTime('2020-01-01 00:00:00')+number*2+1), 1 
from numbers(1000000);

CREATE DICTIONARY curs_dict
(
    `a` Unt64,
    `b` UInt64,
    `e` UInt64,
    `rate` UInt16
)
PRIMARY KEY a
SOURCE(CLICKHOUSE(TABLE curs DB 'default' USER 'default'))
LIFETIME(MIN 0 MAX 10)
LAYOUT(RANGE_HASHED)
RANGE(MIN b MAX e);

0 rows in set. Elapsed: 115.715 sec.


SELECT sum(dictGetUInt16('curs_dict', 'rate', toUInt64(1), toYYYYMMDDhhmmss((toDateTime('2020-01-01 00:00:00') + (number * 2)) + 1))) AS s
FROM numbers(10000);

Elapsed: 0.023 sec.


SELECT sum(dictGetUInt16('curs_dict', 'rate', toUInt64(1), toYYYYMMDDhhmmss((toDateTime('2020-01-01 00:00:00') + (number * 2)) + 1))) AS s
FROM numbers(100000)

Elapsed: 2.264 sec.   / Expected  0.023*10 ~ 0.230

SELECT sum(dictGetUInt16('curs_dict', 'rate', toUInt64(1), toYYYYMMDDhhmmss((toDateTime('2020-01-01 00:00:00') + (rand())) + 1))) AS s
FROM numbers(100000)

Hangs forever
```
const auto key = keys_extractor.extractCurrentKey();
            const auto it = collection.find(key);
            if (it)
            {
                const auto date = dates[key_index];
                const auto & ranges_and_values = it->getMapped();
                const auto val_it = std::find_if(
                    std::begin(ranges_and_values),
                    std::end(ranges_and_values),
                    [date](const Value<ValueType> & v)
                    {
                        return v.range.contains(date);
                    });
                out[key_index] = val_it != std::end(ranges_and_values);
                keys_found += out[key_index];
            }
            else
            {
                out[key_index] = false;
            }
            keys_extractor.rollbackCurrentKey();
        }
    };
    callOnDictionaryAttributeType(attribute.type, type_call);
    query_count.fetch_add(keys_size, std::memory_order_relaxed);
    found_count.fetch_add(keys_found, std::memory_order_relaxed);
    return result;
}
template <DictionaryKeyType dictionary_key_type>
void RangeHashedDictionary<dictionary_key_type>::createAttributes()