Method ResolveTemplateTypes

src/function/function_binder.cpp:586–623

}

void FunctionBinder::ResolveTemplateTypes(BaseScalarFunction &bound_function,
                                          const vector<unique_ptr<Expression>> &children) {
	case_insensitive_map_t<vector<LogicalType>> bindings;
	vector<reference<LogicalType>> to_substitute;

	// First, we need to infer the template types from the children.
	for (idx_t i = 0; i < bound_function.arguments.size(); i++) {
		auto &param = bound_function.arguments[i];

		// If the parameter is not templated, we can skip it.
		if (param.IsTemplated()) {
			auto actual = ExpressionBinder::GetExpressionReturnType(*children[i]);
			InferTemplateType(context, param, actual, bindings, *children[i], bound_function);

			to_substitute.emplace_back(param);
		}
	}

	// If the function has a templated varargs, we need to infer its type too
	if (bound_function.varargs.IsTemplated()) {
		// All remaining children are considered varargs.
		for (idx_t i = bound_function.arguments.size(); i < children.size(); i++) {
			auto actual = ExpressionBinder::GetExpressionReturnType(*children[i]);
			InferTemplateType(context, bound_function.varargs, actual, bindings, *children[i], bound_function);
		}
		to_substitute.emplace_back(bound_function.varargs);
	}

	// If the return type is templated, we need to subsitute it as well
	if (bound_function.GetReturnType().IsTemplated()) {
		to_substitute.emplace_back(bound_function.GetReturnType());
	}

	// Finally, substitute all template types in the bound function with their concrete types.
	for (auto &templated_type : to_substitute) {
		SubstituteTemplateType(templated_type, bindings, bound_function.name);
	}
}

static void VerifyTemplateType(const LogicalType &type, const string &function_name) {
	TypeVisitor::Contains(type, [&](const LogicalType &type) {