Function buildPhysicalJoinImpl

src/Processors/QueryPlan/JoinStepLogical.cpp:1071–1405

}

static QueryPlanNode buildPhysicalJoinImpl(
    std::vector<QueryPlanNode *> children,
    JoinOperator join_operator,
    JoinExpressionActions expression_actions,
    JoinSettings join_settings,
    JoinAlgorithmParams join_algorithm_params,
    SortingStep::Settings sorting_settings,
    const ActionsDAG::NodeRawConstPtrs & actions_after_join,
    const QueryPlanOptimizationSettings & optimization_settings,
    QueryPlan::Nodes & nodes,
    LogicalJoinInfo && logical_join_info)
{
    auto * logical_lookup = typeid_cast<JoinStepLogicalLookup *>(children.back()->step.get());

    auto table_join = std::make_shared<TableJoin>(join_settings, logical_lookup && logical_lookup->useNulls(),
        Context::getGlobalContextInstance()->getGlobalTemporaryVolume(),
        Context::getGlobalContextInstance()->getTempDataOnDisk());

    PreparedJoinStorage prepared_join_storage;
    if (logical_lookup)
    {
        prepared_join_storage = std::move(logical_lookup->getPreparedJoinStorage());
        prepared_join_storage.visit([&table_join](const auto & storage_)
        {
            table_join->setStorageJoin(storage_);
        });
    }

    auto & join_expression = join_operator.expression;

    bool is_join_without_expression = isCrossOrComma(join_operator.kind) || isPaste(join_operator.kind);
    /// When we do JOIN ON NULL or JOIN ON 1 we create dummy columns and in fact joining on 1 = 0 or 1 = 1.
    /// For INNER JOIN we could just do CROSS, but for OUTER result depends on whether any table is empty or not.
    if ((!is_join_without_expression && join_expression.empty()) ||
        (join_expression.size() == 1
            && join_expression[0].getType()->onlyNull()
            && std::get<0>(join_expression[0].asBinaryPredicate()) == JoinConditionOperator::Unknown))
    {
        UInt8 rhs_value = join_expression.empty() ? 1 : 0;
        join_expression.clear();

        auto actions_dag = expression_actions.getActionsDAG();

        auto dt = std::make_shared<DataTypeUInt8>();

        auto lhs_column = dt->createColumnConst(0, 1);
        JoinActionRef lhs(&actions_dag->addColumn(std::move(lhs_column), dt, "__lhs_const"), expression_actions);
        lhs.setSourceRelations(BitSet().set(0));

        auto rhs_column = dt->createColumnConst(0, rhs_value);
        JoinActionRef rhs(&actions_dag->addColumn(std::move(rhs_column), dt, "__rhs_const"), expression_actions);
        rhs.setSourceRelations(BitSet().set(1));

        join_expression.push_back(JoinActionRef::transform({lhs, rhs}, JoinActionRef::AddFunction(JoinConditionOperator::Equals)));

        table_join->setIsJoinWithConstant(true);
    }