Method getItemsShortCircuitImpl

src/Dictionaries/HashedArrayDictionary.cpp:898–944

template <DictionaryKeyType dictionary_key_type, bool sharded>
template <typename AttributeType, bool is_nullable, typename ValueSetter>
void HashedArrayDictionary<dictionary_key_type, sharded>::getItemsShortCircuitImpl(
    const Attribute & attribute,
    DictionaryKeysExtractor<dictionary_key_type> & keys_extractor,
    ValueSetter && set_value,
    IColumn::Filter & default_mask) const
{
    const auto & attribute_containers = std::get<AttributeContainerShardsType<AttributeType>>(attribute.containers);
    const size_t keys_size = keys_extractor.getKeysSize();
    default_mask.resize(keys_size);
    size_t keys_found = 0;

    for (size_t key_index = 0; key_index < keys_size; ++key_index)
    {
        auto key = keys_extractor.extractCurrentKey();
        auto shard = getShard(key);
        const auto & key_attribute_container = key_attribute.containers[shard];
        const auto & attribute_container = attribute_containers[shard];

        const auto it = key_attribute_container.find(key);

        if (it != key_attribute_container.end())
        {
            size_t element_index = it->getMapped();

            const auto & element = attribute_container[element_index];

            if constexpr (is_nullable)
                set_value(key_index, element, (*attribute.is_index_null)[shard][element_index]);
            else
                set_value(key_index, element, false);

            default_mask[key_index] = 0;

            ++keys_found;
        }
        else
        {
            default_mask[key_index] = 1;
            set_value(key_index, AttributeType{}, true);
        }

        keys_extractor.rollbackCurrentKey();
    }

    query_count.fetch_add(keys_size, std::memory_order_relaxed);
    found_count.fetch_add(keys_found, std::memory_order_relaxed);
}

template <DictionaryKeyType dictionary_key_type, bool sharded>
template <typename AttributeType, bool is_nullable, typename ValueSetter, typename DefaultValueExtractor>