Method joinBlock

src/Interpreters/NestedLoopJoin.cpp:152–197

}

void NestedLoopJoin::joinBlock(Block & left_block, ExtraBlockPtr &)
{
    auto left_rows = left_block.rows();
    materializeBlockInplace(left_block);
    JoinCommon::removeLowCardinalityInplace(left_block);

    NamesAndTypesList total_columns = left_block.cloneEmpty().getNamesAndTypesList();
    completeColumnsAfterJoin(total_columns);

    if (table_join->hasOn() || table_join->hasUsing())
    {
        // generate actions for on expression
        ASTPtr expression_list = nullptr;
        if (table_join->hasOn())
            expression_list = table_join->getOnExpression();
        else
        {
            const auto & null_safe_columns = table_join->keyIdsNullSafe();
            std::vector<std::shared_ptr<ASTFunction>> conds;

            for (size_t i = 0; i < table_join->keyNamesLeft().size(); i++) {
                const String fn = null_safe_columns && (*null_safe_columns)[i] ? "bitEquals" : "equals";

                conds.emplace_back(makeASTFunction(fn,
                                                   std::make_shared<ASTIdentifier>(table_join->keyNamesLeft()[i]),
                                                   std::make_shared<ASTIdentifier>(table_join->keyNamesRight()[i])));
            }
            expression_list = conds[0];
            for (size_t i = 1; i < conds.size(); i++)
                expression_list = makeASTFunction("and", expression_list, conds[i]);
        }
        auto syntax_result
                = TreeRewriter(context).analyze(expression_list, total_columns);

        auto actions = ExpressionAnalyzer(expression_list, syntax_result, context).getActions(true, false);

        String filter_name = expression_list->getColumnName();
        if (left_rows == 0)
        {
            completeHeader(left_block);
            return;
        }

        joinImpl(actions, filter_name, left_block);
    }
}

void NestedLoopJoin::completeColumnsAfterJoin(NamesAndTypesList & total_columns)
{