The SubqueryScope is managed through the whole resolution process of a given SubqueryExpression plan.

The reason why we need this scope is that AggregateExpressions with OuterReferences are handled in a special way. Consider this query:

-- t1.col2 is an outer reference
SELECT col1 FROM VALUES (1, 2) t1 GROUP BY col1 HAVING (
  SELECT * FROM VALUES (1, 2) t2 WHERE t2.col2 == MAX(t1.col2)
)

During the Exists resolution inside the HAVING clause we encounter "t1.col2" name, which is resolved to an OuterReference. There's an AggregateExpression on top of it. This whole expression is not local to the subquery, and thus it belongs to an outer Aggregate operator below the HAVING clause. We need top pull it up outside of the subquery, and insert it in the Aggregate operator. So the resolution order is as follows:

• Resolve "t1.col2" to an OuterReference in ExpressionResolver.resolveAttribute;
• Resolve the AggregateExpression in AggregateExpressionResolver.resolve;
• Detect an outer reference below the aggregate expression, cut the whole subtree with outer references stripped away, alias it and insert it in this SubqueryScope;
• Replace the aggregate expression with an OuterReference to the AttributeReference from that artificial Alias;
• When the resolution of the SubqueryExpression is finished, SubqueryRegistry.popScope merges the lower scope to the upper one, and all the outer aggregate expression references are appended to the common lowerAliasedOuterAggregateExpressions list.
• Finally, the resolution of the HAVING clause can insert the missing aggregate expression into the lower Aggregate operator. During this process we must call ExpressionIdAssigner.mapExpression on the new alias, because this auto-generated alias is new to the query plan, so that ExpressionIdAssigner remembers it.

Notes:

• Spark only supports outer aggregates in the subqueries inside HAVING;
• The subtree under a given AggregateExpression can be arbitrary, but must contain either local or outer references, the mixed set is disallowed.
• We can have several subquery expressions in HAVING clause, that's why we append outer aggregate expressions from lower scopes in mergeChildScope.