Method analyzeArrayJoin

src/Analyzers/QueryAnalyzer.cpp:1292–1352

}

ScopePtr QueryAnalyzerVisitor::analyzeArrayJoin(ASTArrayJoin & array_join, ASTSelectQuery & select_query, ScopePtr source_scope)
{
    ASTPtr array_join_expression_list = array_join.expression_list;
    if (array_join_expression_list->children.empty())
        throw DB::Exception("ARRAY JOIN requires an argument", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);

    ExprAnalyzerOptions expr_options{"Array Join expression"};
    expr_options.selectQuery(select_query)
        .subquerySupport(ExprAnalyzerOptions::SubquerySupport::DISALLOWED)
        .aggregateSupport(ExprAnalyzerOptions::AggregateSupport::DISALLOWED)
        .windowSupport(ExprAnalyzerOptions::WindowSupport::DISALLOWED);

    ArrayJoinDescriptions array_join_descs;
    FieldDescriptions output_fields = source_scope->getFields();
    NameSet name_set;
    for (auto & array_join_expr : array_join_expression_list->children)
    {
        if (array_join_expr->tryGetAlias() == array_join_expr->getColumnName() && !array_join_expr->as<ASTIdentifier>())
            throw Exception("No alias for non-trivial value in ARRAY JOIN: " + array_join_expr->tryGetAlias(), ErrorCodes::ALIAS_REQUIRED);

        String output_name = array_join_expr->getAliasOrColumnName();
        if (name_set.count(output_name))
            throw Exception("Duplicate alias in ARRAY JOIN: " + output_name, ErrorCodes::MULTIPLE_EXPRESSIONS_FOR_ALIAS);

        auto array_join_expr_type = ExprAnalyzer::analyze(array_join_expr, source_scope, context, analysis, expr_options);
        const auto array_type = getArrayJoinDataType(array_join_expr_type);
        if (!array_type)
            throw Exception("ARRAY JOIN requires array argument", ErrorCodes::TYPE_MISMATCH);

        auto col_ref = analysis.tryGetColumnReference(array_join_expr);
        // To determine if a scope is from outer query, we should use Scope::isLocalScope.
        // Practically, scopes belonging to FROM clause don't have parent scopes, so we can use operator== for convenience.
        if (col_ref && source_scope != col_ref->scope)
            throw Exception(
                "Outer query columns cannot be used in ARRAY JOIN: " + array_join_expr->getColumnName(), ErrorCodes::BAD_ARGUMENTS);

        ArrayJoinDescription array_join_desc;
        array_join_desc.expr = array_join_expr;

        if (col_ref && array_join_expr->tryGetAlias().empty()) // ARRAY JOIN `arr`
        {
            output_fields[col_ref->local_index] = FieldDescription{output_fields[col_ref->local_index].name, array_type->getNestedType()};
        }
         else if (col_ref && !array_join_expr->tryGetAlias().empty() && array_join_expr->tryGetAlias() == output_fields[col_ref->local_index].name) // ARRAY JOIN `arr` as `arr`
        {
            output_fields[col_ref->local_index] = FieldDescription{output_fields[col_ref->local_index].name, array_type->getNestedType()};
        }
        else // ARRAY JOIN `arr` as `arr2`
        {
            array_join_desc.create_new_field = true;
            output_fields.emplace_back(output_name, array_type->getNestedType());
        }

        array_join_descs.emplace_back(std::move(array_join_desc));
    }

    analysis.array_join_analysis[&select_query] = ArrayJoinAnalysis{(array_join.kind == ASTArrayJoin::Kind::Left), array_join_descs};
    ScopePtr output_scope = createScope(output_fields);