v1-improve-function-lookup-failure-errors.patch

diff --git a/src/backend/catalog/namespace.c b/src/backend/catalog/namespace.c
index d97d632a7ef..100c58b658a 100644
--- a/src/backend/catalog/namespace.c
+++ b/src/backend/catalog/namespace.c
@@ -1184,17 +1184,24 @@ TypeIsVisibleExt(Oid typid, bool *is_missing)
  * The caller might end up discarding such an entry anyway, but if it selects
  * such an entry it should react as though the call were ambiguous.
  *
- * If missing_ok is true, an empty list (NULL) is returned if the name was
- * schema-qualified with a schema that does not exist.  Likewise if no
- * candidate is found for other reasons.
+ * We return an empty list (NULL) if no suitable matches can be found.
+ * *bad_argnames is set true if there were matches to the function name
+ * but not to the argnames, or to false in all other cases.
+ *
+ * If the function name was schema-qualified with a schema that does not
+ * exist, then we return an empty list if missing_ok is true and otherwise
+ * throw an error.  (missing_ok does not affect the behavior otherwise.)
  */
 FuncCandidateList
 FuncnameGetCandidates(List *names, int nargs, List *argnames,
 					  bool expand_variadic, bool expand_defaults,
-					  bool include_out_arguments, bool missing_ok)
+					  bool include_out_arguments, bool missing_ok,
+					  bool *bad_argnames)
 {
 	FuncCandidateList resultList = NULL;
 	bool		any_special = false;
+	bool		found_name_match = false;
+	bool		found_argnames_match = false;
 	char	   *schemaname;
 	char	   *funcname;
 	Oid			namespaceId;
@@ -1204,6 +1211,9 @@ FuncnameGetCandidates(List *names, int nargs, List *argnames,
 	/* check for caller error */
 	Assert(nargs >= 0 || !(expand_variadic | expand_defaults));
 
+	/* set default output */
+	*bad_argnames = false;
+
 	/* deconstruct the name list */
 	DeconstructQualifiedName(names, &schemaname, &funcname);
 
@@ -1263,6 +1273,9 @@ FuncnameGetCandidates(List *names, int nargs, List *argnames,
 				continue;		/* proc is not in search path */
 		}
 
+		/* Okay, we have a name (and schema) match */
+		found_name_match = true;
+
 		/*
 		 * If we are asked to match to OUT arguments, then use the
 		 * proallargtypes array (which includes those); otherwise use
@@ -1331,6 +1344,9 @@ FuncnameGetCandidates(List *names, int nargs, List *argnames,
 								&argnumbers))
 				continue;
 
+			/* We have found at least one match to the argument names */
+			found_argnames_match = true;
+
 			/* Named argument matching is always "special" */
 			any_special = true;
 		}
@@ -1557,6 +1573,14 @@ FuncnameGetCandidates(List *names, int nargs, List *argnames,
 
 	ReleaseSysCacheList(catlist);
 
+	/*
+	 * Detect case where there were possible matches but they all failed to
+	 * match the given argnames.
+	 */
+	if (resultList == NULL && argnames != NIL &&
+		found_name_match && !found_argnames_match)
+		*bad_argnames = true;
+
 	return resultList;
 }
 
@@ -1746,11 +1770,13 @@ FunctionIsVisibleExt(Oid funcid, bool *is_missing)
 		char	   *proname = NameStr(procform->proname);
 		int			nargs = procform->pronargs;
 		FuncCandidateList clist;
+		bool		bad_argnames;
 
 		visible = false;
 
 		clist = FuncnameGetCandidates(list_make1(makeString(proname)),
-									  nargs, NIL, false, false, false, false);
+									  nargs, NIL, false, false, false, false,
+									  &bad_argnames);
 
 		for (; clist; clist = clist->next)
 		{
diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c
index 583bbbf232f..e8383ef99d7 100644
--- a/src/backend/parser/parse_func.c
+++ b/src/backend/parser/parse_func.c
@@ -601,9 +601,30 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 
 		/*
 		 * No function, and no column either.  Since we're dealing with
-		 * function notation, report "function does not exist".
+		 * function notation, report "function/procedure does not exist"
+		 * rather than mentioning columns.  We have a couple of different
+		 * things to say as detail or hint, though.
 		 */
-		if (list_length(agg_order) > 1 && !agg_within_group)
+		if (fdresult == FUNCDETAIL_BAD_ARGNAMES)
+		{
+			if (proc_call)
+				ereport(ERROR,
+						(errcode(ERRCODE_UNDEFINED_FUNCTION),
+						 errmsg("procedure %s does not exist",
+								func_signature_string(funcname, nargs, argnames,
+													  actual_arg_types)),
+						 errdetail("No procedure matches the given argument name(s)."),
+						 parser_errposition(pstate, location)));
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_UNDEFINED_FUNCTION),
+						 errmsg("function %s does not exist",
+								func_signature_string(funcname, nargs, argnames,
+													  actual_arg_types)),
+						 errdetail("No function matches the given argument name(s)."),
+						 parser_errposition(pstate, location)));
+		}
+		else if (list_length(agg_order) > 1 && !agg_within_group)
 		{
 			/* It's agg(x, ORDER BY y,z) ... perhaps misplaced ORDER BY */
 			ereport(ERROR,
@@ -1410,6 +1431,7 @@ func_get_detail(List *funcname,
 {
 	FuncCandidateList raw_candidates;
 	FuncCandidateList best_candidate;
+	bool		bad_argnames;
 
 	/* initialize output arguments to silence compiler warnings */
 	*funcid = InvalidOid;
@@ -1424,7 +1446,8 @@ func_get_detail(List *funcname,
 	/* Get list of possible candidates from namespace search */
 	raw_candidates = FuncnameGetCandidates(funcname, nargs, fargnames,
 										   expand_variadic, expand_defaults,
-										   include_out_arguments, false);
+										   include_out_arguments, false,
+										   &bad_argnames);
 
 	/*
 	 * Quickly check if there is an exact match to the input datatypes (there
@@ -1594,7 +1617,7 @@ func_get_detail(List *funcname,
 		 */
 		if (fargnames != NIL && !expand_variadic && nargs > 0 &&
 			best_candidate->argnumbers[nargs - 1] != nargs - 1)
-			return FUNCDETAIL_NOTFOUND;
+			return FUNCDETAIL_BAD_ARGNAMES;
 
 		*funcid = best_candidate->oid;
 		*nvargs = best_candidate->nvargs;
@@ -1719,6 +1742,12 @@ func_get_detail(List *funcname,
 		return result;
 	}
 
+	/*
+	 * For error reporting purposes, we want to distinguish the case of
+	 * could-not-find-an-argnames-match from other cases.
+	 */
+	if (bad_argnames)
+		return FUNCDETAIL_BAD_ARGNAMES;
 	return FUNCDETAIL_NOTFOUND;
 }
 
@@ -2053,6 +2082,7 @@ LookupFuncNameInternal(ObjectType objtype, List *funcname,
 {
 	Oid			result = InvalidOid;
 	FuncCandidateList clist;
+	bool		bad_argnames;
 
 	/* NULL argtypes allowed for nullary functions only */
 	Assert(argtypes != NULL || nargs == 0);
@@ -2062,7 +2092,8 @@ LookupFuncNameInternal(ObjectType objtype, List *funcname,
 
 	/* Get list of candidate objects */
 	clist = FuncnameGetCandidates(funcname, nargs, NIL, false, false,
-								  include_out_arguments, missing_ok);
+								  include_out_arguments, missing_ok,
+								  &bad_argnames);
 
 	/* Scan list for a match to the arg types (if specified) and the objtype */
 	for (; clist != NULL; clist = clist->next)
diff --git a/src/backend/utils/adt/regproc.c b/src/backend/utils/adt/regproc.c
index b8bbe95e82e..9b70305bfc6 100644
--- a/src/backend/utils/adt/regproc.c
+++ b/src/backend/utils/adt/regproc.c
@@ -71,6 +71,7 @@ regprocin(PG_FUNCTION_ARGS)
 	RegProcedure result;
 	List	   *names;
 	FuncCandidateList clist;
+	bool		bad_argnames;
 
 	/* Handle "-" or numeric OID */
 	if (parseDashOrOid(pro_name_or_oid, &result, escontext))
@@ -93,7 +94,8 @@ regprocin(PG_FUNCTION_ARGS)
 	if (names == NIL)
 		PG_RETURN_NULL();
 
-	clist = FuncnameGetCandidates(names, -1, NIL, false, false, false, true);
+	clist = FuncnameGetCandidates(names, -1, NIL, false, false, false, true,
+								  &bad_argnames);
 
 	if (clist == NULL)
 		ereturn(escontext, (Datum) 0,
@@ -164,13 +166,15 @@ regprocout(PG_FUNCTION_ARGS)
 		{
 			char	   *nspname;
 			FuncCandidateList clist;
+			bool		bad_argnames;
 
 			/*
 			 * Would this proc be found (uniquely!) by regprocin? If not,
 			 * qualify it.
 			 */
 			clist = FuncnameGetCandidates(list_make1(makeString(proname)),
-										  -1, NIL, false, false, false, false);
+										  -1, NIL, false, false, false, false,
+										  &bad_argnames);
 			if (clist != NULL && clist->next == NULL &&
 				clist->oid == proid)
 				nspname = NULL;
@@ -231,6 +235,7 @@ regprocedurein(PG_FUNCTION_ARGS)
 	int			nargs;
 	Oid			argtypes[FUNC_MAX_ARGS];
 	FuncCandidateList clist;
+	bool		bad_argnames;
 
 	/* Handle "-" or numeric OID */
 	if (parseDashOrOid(pro_name_or_oid, &result, escontext))
@@ -252,7 +257,8 @@ regprocedurein(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 
 	clist = FuncnameGetCandidates(names, nargs, NIL, false, false,
-								  false, true);
+								  false, true,
+								  &bad_argnames);
 
 	for (; clist; clist = clist->next)
 	{
diff --git a/src/include/catalog/namespace.h b/src/include/catalog/namespace.h
index 8c7ccc69a3c..9ab5fb5daf6 100644
--- a/src/include/catalog/namespace.h
+++ b/src/include/catalog/namespace.h
@@ -102,7 +102,8 @@ extern FuncCandidateList FuncnameGetCandidates(List *names,
 											   bool expand_variadic,
 											   bool expand_defaults,
 											   bool include_out_arguments,
-											   bool missing_ok);
+											   bool missing_ok,
+											   bool *bad_argnames);
 extern bool FunctionIsVisible(Oid funcid);
 
 extern Oid	OpernameGetOprid(List *names, Oid oprleft, Oid oprright);
diff --git a/src/include/parser/parse_func.h b/src/include/parser/parse_func.h
index a6f24b83d84..29af0f58ec0 100644
--- a/src/include/parser/parse_func.h
+++ b/src/include/parser/parse_func.h
@@ -22,6 +22,7 @@
 typedef enum
 {
 	FUNCDETAIL_NOTFOUND,		/* no matching function */
+	FUNCDETAIL_BAD_ARGNAMES,	/* no matching function because of arg names */
 	FUNCDETAIL_MULTIPLE,		/* too many matching functions */
 	FUNCDETAIL_NORMAL,			/* found a matching regular function */
 	FUNCDETAIL_PROCEDURE,		/* found a matching procedure */
diff --git a/src/test/regress/expected/polymorphism.out b/src/test/regress/expected/polymorphism.out
index 94eedfe375e..83576c739b5 100644
--- a/src/test/regress/expected/polymorphism.out
+++ b/src/test/regress/expected/polymorphism.out
@@ -1448,17 +1448,17 @@ select * from dfunc(x := 10, b := 20, c := 30);  -- fail, unknown param
 ERROR:  function dfunc(x => integer, b => integer, c => integer) does not exist
 LINE 1: select * from dfunc(x := 10, b := 20, c := 30);
                       ^
-HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+DETAIL:  No function matches the given argument name(s).
 select * from dfunc(10, 10, a := 20);  -- fail, a overlaps positional parameter
 ERROR:  function dfunc(integer, integer, a => integer) does not exist
 LINE 1: select * from dfunc(10, 10, a := 20);
                       ^
-HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+DETAIL:  No function matches the given argument name(s).
 select * from dfunc(1,c := 2,d := 3); -- fail, no value for b
 ERROR:  function dfunc(integer, c => integer, d => integer) does not exist
 LINE 1: select * from dfunc(1,c := 2,d := 3);
                       ^
-HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+DETAIL:  No function matches the given argument name(s).
 drop function dfunc(int, int, int, int);
 -- test with different parameter types
 create function dfunc(a varchar, b numeric, c date = current_date)