Method BindMacroFunction

src/function/macro_function.cpp:44–255

}

MacroBindResult MacroFunction::BindMacroFunction(
    Binder &binder, const vector<unique_ptr<MacroFunction>> &functions, const string &name,
    FunctionExpression &function_expr, vector<unique_ptr<ParsedExpression>> &positional_arguments,
    InsertionOrderPreservingMap<unique_ptr<ParsedExpression>> &named_arguments, idx_t depth) {
	ExpressionBinder expr_binder(binder, binder.context);
	expr_binder.lambda_bindings = binder.lambda_bindings;

	// Figure out whether we even need to bind arguments
	bool requires_bind = false;
	for (auto &function : functions) {
		for (const auto &type : function->types) {
			if (type.id() != LogicalTypeId::UNKNOWN) {
				requires_bind = true;
				break;
			}
		}
		if (requires_bind) {
			break;
		}
	}

	// Find argument types and separate positional and default arguments
	vector<LogicalType> positional_arg_types;
	InsertionOrderPreservingMap<LogicalType> named_arg_types;
	for (auto &arg : function_expr.children) {
		auto arg_copy = arg->Copy();
		LogicalType arg_type = LogicalType::UNKNOWN;
		if (requires_bind) {
			const auto arg_bind_result = expr_binder.BindExpression(arg_copy, depth + 1);
			arg_type = arg_bind_result.HasError() ? LogicalType::UNKNOWN : arg_bind_result.expression->return_type;
		}
		if (!arg->GetAlias().empty()) {
			// Default argument
			if (named_arguments.find(arg->GetAlias()) != named_arguments.end()) {
				return MacroBindResult(
				    StringUtil::Format("Macro %s() has named argument repeated '%s'", name, arg->GetAlias()));
			}
			named_arg_types.insert(arg->GetAlias(), std::move(arg_type));
			named_arguments[arg->GetAlias()] = std::move(arg);
		} else if (!named_arguments.empty()) {
			return MacroBindResult(
			    StringUtil::Format("Macro %s() has positional argument following named argument", name));
		} else {
			// Positional argument
			positional_arguments.push_back(std::move(arg));
			positional_arg_types.push_back(std::move(arg_type));
		}
	}

	// Check for each macro function if it matches the number of positional arguments
	auto lowest_cost = NumericLimits<idx_t>::Maximum();
	vector<idx_t> result_indices;
	for (idx_t function_idx = 0; function_idx < functions.size(); function_idx++) {
		auto &function = functions[function_idx];

		// At some point we want to guarantee that this has the same size as "parameters", but for now we fill to match
		auto parameter_types = function->types;
		parameter_types.resize(function->parameters.size(), LogicalType::UNKNOWN);