Method joinBlockImpl

src/Interpreters/HashJoin.cpp:1282–1414

template <ASTTableJoin::Kind KIND, ASTTableJoin::Strictness STRICTNESS, typename Maps>
Block HashJoin::joinBlockImpl(
    Block & block,
    const Names & key_names_left,
    const Block & block_with_columns_to_add,
    const Maps & maps_,
    bool is_join_get) const
{
    JoinFeatures<KIND, STRICTNESS, false> join_feature;

    /// Rare case, when keys are constant or low cardinality. To avoid code bloat, simply materialize them.
    const auto *null_safe_columns = table_join->keyIdsNullSafe();
    Columns materialized_keys = JoinCommon::materializeColumns(block, key_names_left, null_safe_columns);
    ColumnRawPtrs left_key_columns = JoinCommon::getRawPointers(materialized_keys);

    /// Keys with NULL value in any column won't join to anything.
    ConstNullMapPtr null_map{};
    ColumnPtr null_map_holder = extractNestedColumnsAndNullMap(left_key_columns, null_map, null_safe_columns);

    size_t existing_columns = block.columns();

    /** If you use FULL or RIGHT JOIN, then the columns from the "left" table must be materialized.
      * Because if they are constants, then in the "not joined" rows, they may have different values
      *  - default values, which can differ from the values of these constants.
      */
    if constexpr (join_feature.right || join_feature.full)
    {
        materializeBlockInplace(block);
        if (nullable_left_side)
            JoinCommon::convertColumnsToNullable(block);
    }

    /** For LEFT/INNER JOIN, the saved blocks do not contain keys.
      * For FULL/RIGHT JOIN, the saved blocks contain keys;
      *  but they will not be used at this stage of joining (and will be in `AdderNonJoined`), and they need to be skipped.
      * For ASOF, the last column is used as the ASOF column
      */
    AddedColumns added_columns(block_with_columns_to_add, block, savedBlockSample(), *this, left_key_columns, key_sizes, join_feature.is_asof_join, is_join_get);
    bool has_required_right_keys = (required_right_keys.columns() != 0);
    added_columns.need_filter = join_feature.need_filter || has_required_right_keys;
    Stopwatch watch;
    added_columns.max_joined_block_rows = table_join->maxJoinedBlockRows();
    if (!added_columns.max_joined_block_rows)
        added_columns.max_joined_block_rows = std::numeric_limits<size_t>::max();
    else
        added_columns.reserve(join_feature.need_replication);

    size_t num_joined = overDictionary() ?
        dictionaryJoinRightColumns<KIND, STRICTNESS>(*table_join, added_columns, null_map) :
        switchJoinRightColumns<KIND, STRICTNESS>(maps_, added_columns, data->type, null_map, used_flags, false);
    Block remaining_block = sliceBlock(block, num_joined);

    for (size_t i = 0; i < added_columns.size(); ++i)
        block.insert(added_columns.moveColumn(i));

    std::vector<size_t> right_keys_to_replicate [[maybe_unused]];

    if (join_feature.need_filter)
    {