```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
```
return true;
        }
        else
        {
            return false;
        }
    };
    if (!callOnIndexAndDataType<void>(type->getTypeId(), type_call))
        throw Exception(ErrorCodes::LOGICAL_ERROR, "RangeHashedDictionary min max range type should be numeric");
    ColumnsWithTypeAndName data_columns = {std::move(range_min_column), std::move(range_max_column)};
    std::shared_ptr<const IDictionary> dictionary = shared_from_this();
    auto coordinator = DictionarySourceCoordinator::create(dictionary, column_names, std::move(key_columns), std::move(data_columns), max_block_size);
    auto result = coordinator->read(num_streams);
    return result;
}
void registerDictionaryRangeHashed(DictionaryFactory & factory)
{
    auto create_layout_simple = [=](const std::string & full_name,
                             const DictionaryStructure & dict_struct,
                             const Poco::Util::AbstractConfiguration & config,
                             const std::string & config_prefix,
                             DictionarySourcePtr source_ptr,
                             ContextPtr ,
                             bool ) -> DictionaryPtr
    {
        if (dict_struct.key)
            throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "'key' is not supported for dictionary of layout 'range_hashed'");
        if (!dict_struct.range_min || !dict_struct.range_max)
            throw Exception(ErrorCodes::BAD_ARGUMENTS,
                "{}: dictionary of layout 'range_hashed' requires .structure.range_min and .structure.range_max",