Function resolve_lambda_variables

datafusion/expr/src/higher_order_function.rs:1112–1148

(
    expr: Expr,
    schema: &DFSchema,
    // a map of lambda variable name => a never empty stack of fields [ [..shadowed], in_scope ]
    vars: &mut HashMap<String, Vec<FieldRef>>,
)

}

pub(crate) fn resolve_lambda_variables(
    expr: Expr,
    schema: &DFSchema,
    // a map of lambda variable name => a never empty stack of fields [ [..shadowed], in_scope ]
    vars: &mut HashMap<String, Vec<FieldRef>>,
) -> Result<Transformed<Expr>> {
    expr.transform_down(|expr| match expr {
        Expr::HigherOrderFunction(HigherOrderFunction { func, args }) => {
            // not inlined to reduce nesting
            resolve_higher_order_function(func, args, schema, vars)
        }
        Expr::LambdaVariable(mut var) => {
            let field_stack = vars.get(&var.name).ok_or_else(|| {
                plan_datafusion_err!(
                    "missing field of lambda variable {} while resolving",
                    var.name
                )
            })?;

            let field = field_stack.last().ok_or_else(|| {
                internal_datafusion_err!("every entry should have at least one field")
            })?;

            let field = Arc::clone(field).renamed(&var.name);

            let transformed = var.field.as_ref().is_none_or(|old| old != &field);

            var.field = Some(field);

            Ok(Transformed::new_transformed(
                Expr::LambdaVariable(var),
                transformed,
            ))
        }
        _ => Ok(Transformed::no(expr)),
    })
}

fn resolve_higher_order_function(
    func: Arc<HigherOrderUDF>,