Function extractMapColumnKeys

src/QueryPlan/ReadFromMergeTree.cpp:103–165

}

static Array extractMapColumnKeys(const MergeTreeMetaBase & data, const MergeTreeMetaBase::DataPartsVector & parts)
{
    Array res;

    std::unordered_map<String, DataTypePtr> map_types;
    std::unordered_map<String, MutableColumnPtr> map_keys;
    /// get all map columns from storage
    StorageMetadataPtr metadata = data.getInMemoryMetadataPtr();
    const auto & columns = metadata->getColumns();
    for (auto it = columns.begin(); it != columns.end(); it++)
    {
        if (it->type->isMap() && it->type->isByteMap())
            map_types[it->name] = it->type;
    }

    Poco::Logger * logger = nullptr;
    for (auto & part : parts)
    {
        for (auto & [file, _] : part->getChecksums()->files)
        {
            if (!isMapImplicitKey(file) || isMapBaseFile(file))
                continue;

            String map_name = parseMapNameFromImplicitFileName(file);
            if (!isMapImplicitDataFileNameNotBaseOfSpecialMapName(file, map_name))
                continue;
            String key_name = parseKeyNameFromImplicitFileName(file, map_name);

            if (!map_types.count(map_name))
            {
                if (unlikely(logger == nullptr))
                    logger = &Poco::Logger::get(data.getLogName() + " (ExtractMapKeys)");
                LOG_WARNING(logger, "Can not find byte map column {} of implicit file {}", map_name, file);
                continue;
            }
            auto type = map_types[map_name];
            auto map_key_type = static_cast<const DataTypeMap *>(type.get())->getKeyType();
            if (!map_keys.count(map_name))
                map_keys[map_name] = IColumn::mutate(map_key_type->createColumn());

            map_keys[map_name]->insert(map_key_type->stringToVisitorField(key_name));
        }
    }

    for (auto & [map_name, column] : map_keys)
    {
        auto type_it = map_types.find(map_name);
        if (type_it == map_types.end())
            throw Exception(ErrorCodes::LOGICAL_ERROR, "Can not find column {}", map_name);

        auto map_key_type = static_cast<const DataTypeMap *>(type_it->second.get())->getKeyType();
        auto serialization = map_key_type->getDefaultSerialization();

        for (size_t i = 0; i < column->size(); ++i)
        {
            WriteBufferFromOwnString buffer;
            serialization->serializeText(*column, i, buffer, {});
            res.push_back(Tuple{map_name, buffer.str()});