Method joinBlock

src/Interpreters/HashJoin/HashJoin.cpp:1264–1323

}

JoinResultPtr HashJoin::joinBlock(Block block)
{
    if (!data)
        throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot join after data has been released");

    for (const auto & onexpr : table_join->getClauses())
    {
        auto cond_column_name = onexpr.condColumnNames();
        JoinCommon::checkTypesOfKeys(
            block, onexpr.key_names_left, cond_column_name.first, right_sample_block, onexpr.key_names_right, cond_column_name.second);
    }

    if (kind == JoinKind::Cross || kind == JoinKind::Comma)
        return joinBlockImplCross(std::move(block));

    materializeColumnsFromLeftBlock(block);

    const bool prefer_use_maps_all = preferUseMapsAll();
    {
        std::vector<const std::decay_t<decltype(data->maps[0])> *> maps_vector;
        maps_vector.reserve(table_join->getClauses().size());
        for (size_t i = 0; i < table_join->getClauses().size(); ++i)
            maps_vector.push_back(&data->maps[i]);

        JoinResultPtr res;
        if (joinDispatch(
                kind,
                strictness,
                maps_vector,
                prefer_use_maps_all,
                [&](auto kind_, auto strictness_, auto & maps_vector_)
                {
                    if constexpr (std::is_same_v<std::decay_t<decltype(maps_vector_)>, std::vector<const MapsAll *>>)
                    {
                        res = HashJoinMethods<kind_, strictness_, MapsAll>::joinBlockImpl(
                            *this, std::move(block), sample_block_with_columns_to_add, maps_vector_);
                    }
                    else if constexpr (std::is_same_v<std::decay_t<decltype(maps_vector_)>, std::vector<const MapsOne *>>)
                    {
                        res = HashJoinMethods<kind_, strictness_, MapsOne>::joinBlockImpl(
                            *this, std::move(block), sample_block_with_columns_to_add, maps_vector_);
                    }
                    else if constexpr (std::is_same_v<std::decay_t<decltype(maps_vector_)>, std::vector<const MapsAsof *>>)
                    {
                        res = HashJoinMethods<kind_, strictness_, MapsAsof>::joinBlockImpl(
                            *this, std::move(block), sample_block_with_columns_to_add, maps_vector_);
                    }
                    else
                    {
                        throw Exception(ErrorCodes::LOGICAL_ERROR, "Unknown maps type");
                    }
                }))
        {
            /// Joined
            return res;
        }
        else
            throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong JOIN combination: {} {}", strictness, kind);