Coerces the expression types by applying necessary transformations on the expression and its children. Because fixed-point sometimes resolves type coercion in multiple passes, we apply each provided transformation twice, cyclically, to ensure that types are resolved. For example in a query like:

SELECT '1' + '1'

fixed-point analyzer requires two passes to resolve types.

In the end, we apply DefaultCollationTypeCoercion. See DefaultCollationTypeCoercion doc for more info.

Additionally, we copy the tags and origin in case the call to this method didn't come from ExpressionResolver, where they are copied generically.

The active config object within the current scope. See SQLConf.get for more information.

This method is an expression analysis entry point. The method first checks if the expression has already been resolved (necessary because of partially-unresolved subtrees, see ProducesUnresolvedSubtree). If not already resolved, method takes an unresolved Expression and chooses the right resolve* method using pattern matching on the unresolvedExpression type. This pattern matching enumerates all the expression node types that are supported by the single-pass analysis. When developers introduce a new Expression type to the Catalyst, they should implement a corresponding resolve* method in the ExpressionResolver and add it to this pattern match list.

resolve will be called recursively during the expression tree traversal eventually producing a fully resolved expression subtree or a descriptive error message.

resolve can recursively call resolver to resolve nested operators (e.g. scalar subqueries):

SELECT * FROM VALUES (1), (2) WHERE col1 IN (SELECT 1);

In this case IN is an expression and SELECT 1 is a nested operator tree for which the ExpressionResolver would invoke the Resolver.

This function avoids wrappers like CurrentOrigin.withOrigin to avoid deep recursion stacks, because expression trees may be quite deep.

Resolve aggregate expressions in Aggregate operator.

The Aggregate list can contain different unresolved expressions before the resolution, which will be resolved using generic resolve. However, UnresolvedStar is a special case, because it is expanded into a sequence of NamedExpressions. Because of that this method returns a sequence and doesn't conform to generic resolve interface - it's called directly from the AggregateResolver during Aggregate resolution.

Besides resolution, we do the following:

• If there is a UnresolvedStar in the list we set hasStar to true in order to throw if there are any ordinals in grouping expressions. Example of an invalid query:

SELECT * FROM VALUES(1) GROUP BY 1;

• If there is an expression which has aggregate function in its subtree, we add it to the expressionsWithAggregateFunctions list in order to throw if there is any ordinal in grouping expressions which references that aggregate expression. Example of an invalid query:

SELECT count(col1) FROM VALUES(1) GROUP BY 1;

• If the resolved expression is an Alias, add it to scopes.current.topAggregateExpressionsByAliasName so it can be used for grouping expressions resolution, if needed. Example of a query with an Alias:
  1. Implicit alias:

SELECT col1 + col2 FROM VALUES(1, 2) GROUP BY `(col1 + col2)`;

2. Explicit alias:

SELECT 1 AS column GROUP BY column;

While resolving the list, we have to keep track of all the expressions that don't have AggregateExpressions in their subtrees (expressionsWithoutAggregates) and whether any of aggregate expressions (that are not expressionsWithoutAggregates) has attributes in the subtree outside of AggregateExpressionss (hasAttributeOutsideOfAggregateExpressions). This is used when resolving GROUP BY ALL in the AggregateResolver.resolveGroupByAll.

Resolve unresolvedExpression which is a child of parentOperator. This is the main entry point into the ExpressionResolver for operators.

Resolve grouping expressions in Aggregate operator.

It's done for every expression using the resolveExpressionTreeInOperatorImpl. For cases where grouping is done based on aliases the resolution is following:

• If the expression can be resolved using the child's output (scopes.current.output), resolve it that way. Example:

SELECT col1 FROM VALUES(1) GROUP BY `col1`;

• If not, try to resolve it as a top level Alias (which was populated during the resolution of the aggregate expressions). Example:
  1. Group by implicit alias

SELECT concat_ws(' ', 'a', 'b') GROUP BY `concat_ws( , a, b)`;

2. Group by explicit alias

SELECT col1 AS column_1 FROM VALUES(1) GROUP BY column_1;

After resolving the expression, remove the top level Alias if it exists.

The Project list can contain different unresolved expressions before the resolution, which will be resolved using generic resolve. However, UnresolvedStar is a special case, because it is expanded into a sequence of NamedExpressions. Because of that this method returns a sequence and doesn't conform to generic resolve interface - it's called directly from the Resolver during Project resolution.

The output sequence can be larger than the input sequence due to UnresolvedStar expansion.

Try to pop the tag that marks the boundary of the single-pass subtree resolution. ExpressionResolver calls this method to check if the subtree traversal needs to be stopped because lower subtree is already resolved.

Validate if expression is under supported operator or not. In case it's not, add expression to the ExpressionTreeTraversal.invalidExpressionsInTheContextOfOperator list to throw error later, when getLastInvalidExpressionsInTheContextOfOperator is called by the Resolver. Here, we avoid adding AggregateExpressions when they are under a Sort or Filter on top of Aggregate as they are not transformed to attributes at the moment. Please see UnsupportedExpressionInOperatorValidation.isExpressionInUnsupportedOperator for more info.

Resolves generic Expression children and returns its copy with children resolved.

We avoid extra method calls here, because resolveChild usually recurses deeply into resolution, and expression trees may be quite deep.

Resolves QuaternaryExpression children and returns its copy with children resolved.

Resolves TernaryExpression children and returns its copy with children resolved.

Resolves BinaryExpression children and returns its copy with children resolved.

Resolves UnaryExpression children and returns its copy with children resolved.

Helper method used to resolve a subtree that is generated as part of the resolution of some node. Method ensures that the downwards traversal never visits previously resolved nodes by tracking the limits of the traversal with a tag. Invokes a resolver callback to resolve children, but DOES NOT resolve the root of the subtree.

If the result of the callback is the same object as the source expression, we don't perform the downwards traversal. This is both more optimal and a fail-safe mechanism in case we accidentally lose the ResolverTag.SINGLE_PASS_SUBTREE_BOUNDARY tag.

Sets all SQL configurations specified in pairs, calls f, and then restores all SQL configurations.