Qualify and quote the support function in ALTER FUNCTION .. SUPPORT (#8873)

DESCRIPTION: Fixes ALTER FUNCTION .. SUPPORT with a user-defined support
function

`ALTER FUNCTION f SUPPORT my_support` on a distributed function sends
the support function name to the workers exactly as the user typed it.
The workers run the command without the coordinator's `search_path`, so
this only works when the support function is in `public` or
`pg_catalog`. Here the support function exists on every node, in the
same schema as `f`:

```
ALTER FUNCTION func_with_support_2(int, int) SUPPORT my_support;
ERROR:  function my_support(internal) does not exist
CONTEXT:  while executing command on localhost:57638
```

A name that needs quoting also fails, because `AppendDefElemSupport`
prints it with `defGetString`:

```
ALTER FUNCTION func_with_support(int, int) SUPPORT "Support Func";
ERROR:  syntax error at or near "Func"
```

#5849 (for #5844) made the command valid by assuming the support
function exists on the workers. This PR keeps that assumption and
changes two things:

- `QualifyAlterFunctionStmt` resolves the support function the same way
postgres does (`LookupFuncName` with a single `internal` argument) and
qualifies it with its schema.
- The deparser prints the name with `NameListToQuotedString`.

**Test.** I added cases to `function_propagation.sql` for an unqualified
support function in the test schema and for a quoted support function
name. They check `prosupport` on the workers.

- On `main` @ c267b0b, both `ALTER`s fail as shown above and the workers
keep `generate_series_int8_support`.
- With the fix, the workers show `function_propagation_schema."Support
Func", function_propagation_schema.my_support`.

I ran this on PG 17.11 in Docker with `make check-custom-schedule`
(minimal cluster setup + `function_propagation`). `uncrustify` with the
citus-style config reports no changes.

This PR was prepared with an AI coding agent (Claude) working for the
breken-ai account. I reviewed the change and the test output.

(cherry picked from commit bfb8600)
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: d89d1f43-18ea-4405-bd1b-5c3129e391a9

Author: 2 people

src/backend/distributed/deparser/deparse_function_stmts.c

@@ -296,7 +296,8 @@ AppendDefElemSet(StringInfo buf, DefElem *def)
 static void
 AppendDefElemSupport(StringInfo buf, DefElem *def)
 {
-	appendStringInfo(buf, " SUPPORT %s", defGetString(def));
+	appendStringInfo(buf, " SUPPORT %s",
+					 NameListToQuotedString(castNode(List, def->arg)));
 }
 
 

src/backend/distributed/deparser/qualify_function_stmt.c

@@ -21,16 +21,20 @@
 #include "access/htup_details.h"
 #include "catalog/namespace.h"
 #include "catalog/pg_proc.h"
+#include "catalog/pg_type.h"
+#include "nodes/value.h"
 #include "parser/parse_func.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
 
 #include "distributed/deparser.h"
+#include "distributed/listutils.h"
 #include "distributed/version_compat.h"
 
 /* forward declaration for qualify functions */
 static void QualifyFunction(ObjectWithArgs *func, ObjectType type);
 static void QualifyFunctionSchemaName(ObjectWithArgs *func, ObjectType type);
+static void QualifySupportFunctionName(DefElem *supportDefElem);
 
 
 /* AssertObjectTypeIsFunctionType asserts we aren't receiving something we shouldn't */
@@ -59,6 +63,48 @@ QualifyAlterFunctionStmt(Node *node)
 	AssertObjectTypeIsFunctional(stmt->objtype);
 
 	QualifyFunction(stmt->func, stmt->objtype);
+
+	DefElem *action = NULL;
+	foreach_declared_ptr(action, stmt->actions)
+	{
+		if (strcmp(action->defname, "support") == 0)
+		{
+			QualifySupportFunctionName(action);
+		}
+	}
+}
+
+
+/*
+ * QualifySupportFunctionName makes the support function name of an
+ * ALTER FUNCTION .. SUPPORT .. statement fully qualified, so the workers
+ * resolve the same function the coordinator does regardless of search_path.
+ */
+static void
+QualifySupportFunctionName(DefElem *supportDefElem)
+{
+	List *supportName = castNode(List, supportDefElem->arg);
+	char *schemaName = NULL;
+	char *functionName = NULL;
+
+	DeconstructQualifiedName(supportName, &schemaName, &functionName);
+	if (schemaName != NULL)
+	{
+		return;
+	}
+
+	/* support functions take a single internal argument, see interpret_func_support */
+	Oid argTypes[1] = { INTERNALOID };
+	Oid supportOid = LookupFuncName(supportName, 1, argTypes, true);
+	if (!OidIsValid(supportOid))
+	{
+		/* postgres reports the missing function when it executes the statement */
+		return;
+	}
+
+	schemaName = get_namespace_name(get_func_namespace(supportOid));
+	supportDefElem->arg = (Node *) list_make2(makeString(schemaName),
+											  makeString(pstrdup(functionName)));
 }
 
 

src/test/regress/expected/function_propagation.out

@@ -1321,6 +1321,21 @@ CREATE FUNCTION func_with_support_2(int, int) RETURNS bool
   LANGUAGE internal STRICT IMMUTABLE PARALLEL SAFE
   AS $$int4eq$$;
 ALTER FUNCTION func_with_support_2(int, int) SUPPORT generate_series_int8_support;
+-- user-defined support functions must resolve on the workers too, even when the
+-- name is not schema qualified or needs quoting
+CREATE FUNCTION my_support(internal) RETURNS internal
+  LANGUAGE internal STRICT AS $$generate_series_int8_support$$;
+ALTER FUNCTION func_with_support_2(int, int) SUPPORT my_support;
+CREATE FUNCTION "Support Func"(internal) RETURNS internal
+  LANGUAGE internal STRICT AS $$generate_series_int8_support$$;
+ALTER FUNCTION func_with_support(int, int) SUPPORT "Support Func";
+SELECT result FROM run_command_on_workers($$SELECT string_agg(prosupport::regproc::text, ', ' ORDER BY proname) FROM pg_proc WHERE proname IN ('func_with_support', 'func_with_support_2')$$);
+                                       result
+---------------------------------------------------------------------
+ function_propagation_schema."Support Func", function_propagation_schema.my_support
+ function_propagation_schema."Support Func", function_propagation_schema.my_support
+(2 rows)
+
 RESET search_path;
 SET client_min_messages TO WARNING;
 DROP SCHEMA function_propagation_schema CASCADE;

src/test/regress/sql/function_propagation.sql

@@ -861,6 +861,16 @@ CREATE FUNCTION func_with_support_2(int, int) RETURNS bool
 
 ALTER FUNCTION func_with_support_2(int, int) SUPPORT generate_series_int8_support;
 
+-- user-defined support functions must resolve on the workers too, even when the
+-- name is not schema qualified or needs quoting
+CREATE FUNCTION my_support(internal) RETURNS internal
+  LANGUAGE internal STRICT AS $$generate_series_int8_support$$;
+ALTER FUNCTION func_with_support_2(int, int) SUPPORT my_support;
+CREATE FUNCTION "Support Func"(internal) RETURNS internal
+  LANGUAGE internal STRICT AS $$generate_series_int8_support$$;
+ALTER FUNCTION func_with_support(int, int) SUPPORT "Support Func";
+SELECT result FROM run_command_on_workers($$SELECT string_agg(prosupport::regproc::text, ', ' ORDER BY proname) FROM pg_proc WHERE proname IN ('func_with_support', 'func_with_support_2')$$);
+
 RESET search_path;
 SET client_min_messages TO WARNING;
 DROP SCHEMA function_propagation_schema CASCADE;