Method resolveMatcher

src/Analyzer/Resolve/QueryAnalyzer.cpp:2318–2784

Resolve query tree matcher. Check MatcherNode.h for detailed matcher description. Check ColumnTransformers.h for detailed transformers description. * * 1. Populate matched expression nodes resolving qualified or unqualified matcher. * 2. Apply column transformers to matched expression nodes. For strict column transformers save used column names. * 3. Validate strict column transformers.

  * 3. Validate strict column transformers.
  */
ProjectionNames QueryAnalyzer::resolveMatcher(QueryTreeNodePtr & matcher_node, IdentifierResolveScope & scope)
{
    auto & matcher_node_typed = matcher_node->as<MatcherNode &>();

    std::unordered_map<std::string, QueryTreeNodePtr> replace_transformer_mappings;

    QueryTreeNodesWithNames matched_expression_nodes_with_names;

    if (matcher_node_typed.isQualified())
        matched_expression_nodes_with_names = resolveQualifiedMatcher(matcher_node, scope);
    else
        matched_expression_nodes_with_names = resolveUnqualifiedMatcher(matcher_node, scope);

    if (scope.join_use_nulls)
    {
        /** If we are resolving matcher came from the result of JOIN and `join_use_nulls` is set,
          * we need to convert joined column type to Nullable.
          * We are checking all registered_table_expression_nodes which contains all table expressions that are used to resolve matcher.
          * If it's on null side, we need to convert column type to Nullable.
          */
        for (const auto & table_expression : scope.registered_table_expression_nodes)
        {
            const JoinNode * nearest_scope_join_node = table_expression->as<JoinNode>();
            if (!nearest_scope_join_node)
                continue;

            for (auto & [node, node_name] : matched_expression_nodes_with_names)
            {
                auto join_identifier_side = getColumnSideFromJoinTree(node, *nearest_scope_join_node);
                if (!join_identifier_side)
                    continue;
                auto projection_name_it = node_to_projection_name.find(node);
                auto nullable_node = IdentifierResolver::convertJoinedColumnTypeToNullIfNeeded(node, node->getResultType(), nearest_scope_join_node->getKind(), join_identifier_side, scope);
                if (nullable_node)
                {
                    node = nullable_node;
                    /// Set the same projection name for new nullable node
                    if (projection_name_it != node_to_projection_name.end())
                    {
                        node_to_projection_name.emplace(node, projection_name_it->second);
                    }
                }
            }
        }
    }

    /// When an APPLY transformer creates an aggregate function (e.g. `* APPLY x -> argMax(x, number)`
    /// or `* APPLY x -> toString(argMax(x, number))`), the matched columns must NOT be converted to
    /// Nullable here. Aggregate function arguments use pre-aggregation types (non-Nullable); the Nullable
    /// wrapping is handled post-aggregation by Rollup/Cube/GroupingSets transforms. Converting here would
    /// create a type mismatch: the aggregate function would expect Nullable input columns, but the actual
    /// columns in the Aggregating step are non-Nullable.
    /// This causes a crash in AggregateFunctionNullVariadic::addBatchSinglePlace.
    ///
    /// We traverse the APPLY expression tree because the aggregate function may be nested
    /// inside other function calls (e.g. `toString(argMax(x, number))`), not just at the top level.
    /// We use `AggregateFunctionFactory` name lookup (not `FunctionNode::isAggregateFunction`) because
    /// APPLY expressions have not been resolved yet at this point — `FunctionNode::kind` is still `UNKNOWN`.