Adding upstream version 16.2.upstream/16.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2370 insertions, 0 deletions

diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c
new file mode 100644
index 0000000..49c7864
--- /dev/null
+++ b/src/backend/commands/functioncmds.c
@@ -0,0 +1,2370 @@
+/*-------------------------------------------------------------------------
+ *
+ * functioncmds.c
+ *
+ *	  Routines for CREATE and DROP FUNCTION commands and CREATE and DROP
+ *	  CAST commands.
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/commands/functioncmds.c
+ *
+ * DESCRIPTION
+ *	  These routines take the parse tree and pick out the
+ *	  appropriate arguments/flags, and pass the results to the
+ *	  corresponding "FooDefine" routines (in src/catalog) that do
+ *	  the actual catalog-munging.  These routines also verify permission
+ *	  of the user to execute the command.
+ *
+ * NOTES
+ *	  These things must be defined and committed in the following order:
+ *		"create function":
+ *				input/output, recv/send procedures
+ *		"create type":
+ *				type
+ *		"create operator":
+ *				operators
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/genam.h"
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "access/table.h"
+#include "catalog/catalog.h"
+#include "catalog/dependency.h"
+#include "catalog/indexing.h"
+#include "catalog/objectaccess.h"
+#include "catalog/pg_aggregate.h"
+#include "catalog/pg_cast.h"
+#include "catalog/pg_language.h"
+#include "catalog/pg_namespace.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_transform.h"
+#include "catalog/pg_type.h"
+#include "commands/alter.h"
+#include "commands/defrem.h"
+#include "commands/extension.h"
+#include "commands/proclang.h"
+#include "executor/execdesc.h"
+#include "executor/executor.h"
+#include "executor/functions.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "optimizer/optimizer.h"
+#include "parser/analyze.h"
+#include "parser/parse_coerce.h"
+#include "parser/parse_collate.h"
+#include "parser/parse_expr.h"
+#include "parser/parse_func.h"
+#include "parser/parse_type.h"
+#include "pgstat.h"
+#include "tcop/pquery.h"
+#include "tcop/utility.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+#include "utils/fmgroids.h"
+#include "utils/guc.h"
+#include "utils/lsyscache.h"
+#include "utils/memutils.h"
+#include "utils/rel.h"
+#include "utils/snapmgr.h"
+#include "utils/syscache.h"
+#include "utils/typcache.h"
+
+/*
+ *	 Examine the RETURNS clause of the CREATE FUNCTION statement
+ *	 and return information about it as *prorettype_p and *returnsSet.
+ *
+ * This is more complex than the average typename lookup because we want to
+ * allow a shell type to be used, or even created if the specified return type
+ * doesn't exist yet.  (Without this, there's no way to define the I/O procs
+ * for a new type.)  But SQL function creation won't cope, so error out if
+ * the target language is SQL.  (We do this here, not in the SQL-function
+ * validator, so as not to produce a NOTICE and then an ERROR for the same
+ * condition.)
+ */
+static void
+compute_return_type(TypeName *returnType, Oid languageOid,
+					Oid *prorettype_p, bool *returnsSet_p)
+{
+	Oid			rettype;
+	Type		typtup;
+	AclResult	aclresult;
+
+	typtup = LookupTypeName(NULL, returnType, NULL, false);
+
+	if (typtup)
+	{
+		if (!((Form_pg_type) GETSTRUCT(typtup))->typisdefined)
+		{
+			if (languageOid == SQLlanguageId)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("SQL function cannot return shell type %s",
+								TypeNameToString(returnType))));
+			else
+				ereport(NOTICE,
+						(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+						 errmsg("return type %s is only a shell",
+								TypeNameToString(returnType))));
+		}
+		rettype = typeTypeId(typtup);
+		ReleaseSysCache(typtup);
+	}
+	else
+	{
+		char	   *typnam = TypeNameToString(returnType);
+		Oid			namespaceId;
+		char	   *typname;
+		ObjectAddress address;
+
+		/*
+		 * Only C-coded functions can be I/O functions.  We enforce this
+		 * restriction here mainly to prevent littering the catalogs with
+		 * shell types due to simple typos in user-defined function
+		 * definitions.
+		 */
+		if (languageOid != INTERNALlanguageId &&
+			languageOid != ClanguageId)
+			ereport(ERROR,
+					(errcode(ERRCODE_UNDEFINED_OBJECT),
+					 errmsg("type \"%s\" does not exist", typnam)));
+
+		/* Reject if there's typmod decoration, too */
+		if (returnType->typmods != NIL)
+			ereport(ERROR,
+					(errcode(ERRCODE_SYNTAX_ERROR),
+					 errmsg("type modifier cannot be specified for shell type \"%s\"",
+							typnam)));
+
+		/* Otherwise, go ahead and make a shell type */
+		ereport(NOTICE,
+				(errcode(ERRCODE_UNDEFINED_OBJECT),
+				 errmsg("type \"%s\" is not yet defined", typnam),
+				 errdetail("Creating a shell type definition.")));
+		namespaceId = QualifiedNameGetCreationNamespace(returnType->names,
+														&typname);
+		aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(),
+									ACL_CREATE);
+		if (aclresult != ACLCHECK_OK)
+			aclcheck_error(aclresult, OBJECT_SCHEMA,
+						   get_namespace_name(namespaceId));
+		address = TypeShellMake(typname, namespaceId, GetUserId());
+		rettype = address.objectId;
+		Assert(OidIsValid(rettype));
+	}
+
+	aclresult = object_aclcheck(TypeRelationId, rettype, GetUserId(), ACL_USAGE);
+	if (aclresult != ACLCHECK_OK)
+		aclcheck_error_type(aclresult, rettype);
+
+	*prorettype_p = rettype;
+	*returnsSet_p = returnType->setof;
+}
+
+/*
+ * Interpret the function parameter list of a CREATE FUNCTION,
+ * CREATE PROCEDURE, or CREATE AGGREGATE statement.
+ *
+ * Input parameters:
+ * parameters: list of FunctionParameter structs
+ * languageOid: OID of function language (InvalidOid if it's CREATE AGGREGATE)
+ * objtype: identifies type of object being created
+ *
+ * Results are stored into output parameters.  parameterTypes must always
+ * be created, but the other arrays/lists can be NULL pointers if not needed.
+ * variadicArgType is set to the variadic array type if there's a VARIADIC
+ * parameter (there can be only one); or to InvalidOid if not.
+ * requiredResultType is set to InvalidOid if there are no OUT parameters,
+ * else it is set to the OID of the implied result type.
+ */
+void
+interpret_function_parameter_list(ParseState *pstate,
+								  List *parameters,
+								  Oid languageOid,
+								  ObjectType objtype,
+								  oidvector **parameterTypes,
+								  List **parameterTypes_list,
+								  ArrayType **allParameterTypes,
+								  ArrayType **parameterModes,
+								  ArrayType **parameterNames,
+								  List **inParameterNames_list,
+								  List **parameterDefaults,
+								  Oid *variadicArgType,
+								  Oid *requiredResultType)
+{
+	int			parameterCount = list_length(parameters);
+	Oid		   *inTypes;
+	int			inCount = 0;
+	Datum	   *allTypes;
+	Datum	   *paramModes;
+	Datum	   *paramNames;
+	int			outCount = 0;
+	int			varCount = 0;
+	bool		have_names = false;
+	bool		have_defaults = false;
+	ListCell   *x;
+	int			i;
+
+	*variadicArgType = InvalidOid;	/* default result */
+	*requiredResultType = InvalidOid;	/* default result */
+
+	inTypes = (Oid *) palloc(parameterCount * sizeof(Oid));
+	allTypes = (Datum *) palloc(parameterCount * sizeof(Datum));
+	paramModes = (Datum *) palloc(parameterCount * sizeof(Datum));
+	paramNames = (Datum *) palloc0(parameterCount * sizeof(Datum));
+	*parameterDefaults = NIL;
+
+	/* Scan the list and extract data into work arrays */
+	i = 0;
+	foreach(x, parameters)
+	{
+		FunctionParameter *fp = (FunctionParameter *) lfirst(x);
+		TypeName   *t = fp->argType;
+		FunctionParameterMode fpmode = fp->mode;
+		bool		isinput = false;
+		Oid			toid;
+		Type		typtup;
+		AclResult	aclresult;
+
+		/* For our purposes here, a defaulted mode spec is identical to IN */
+		if (fpmode == FUNC_PARAM_DEFAULT)
+			fpmode = FUNC_PARAM_IN;
+
+		typtup = LookupTypeName(NULL, t, NULL, false);
+		if (typtup)
+		{
+			if (!((Form_pg_type) GETSTRUCT(typtup))->typisdefined)
+			{
+				/* As above, hard error if language is SQL */
+				if (languageOid == SQLlanguageId)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+							 errmsg("SQL function cannot accept shell type %s",
+									TypeNameToString(t))));
+				/* We don't allow creating aggregates on shell types either */
+				else if (objtype == OBJECT_AGGREGATE)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+							 errmsg("aggregate cannot accept shell type %s",
+									TypeNameToString(t))));
+				else
+					ereport(NOTICE,
+							(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+							 errmsg("argument type %s is only a shell",
+									TypeNameToString(t))));
+			}
+			toid = typeTypeId(typtup);
+			ReleaseSysCache(typtup);
+		}
+		else
+		{
+			ereport(ERROR,
+					(errcode(ERRCODE_UNDEFINED_OBJECT),
+					 errmsg("type %s does not exist",
+							TypeNameToString(t))));
+			toid = InvalidOid;	/* keep compiler quiet */
+		}
+
+		aclresult = object_aclcheck(TypeRelationId, toid, GetUserId(), ACL_USAGE);
+		if (aclresult != ACLCHECK_OK)
+			aclcheck_error_type(aclresult, toid);
+
+		if (t->setof)
+		{
+			if (objtype == OBJECT_AGGREGATE)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("aggregates cannot accept set arguments")));
+			else if (objtype == OBJECT_PROCEDURE)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("procedures cannot accept set arguments")));
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("functions cannot accept set arguments")));
+		}
+
+		/* handle input parameters */
+		if (fpmode != FUNC_PARAM_OUT && fpmode != FUNC_PARAM_TABLE)
+		{
+			/* other input parameters can't follow a VARIADIC parameter */
+			if (varCount > 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("VARIADIC parameter must be the last input parameter")));
+			inTypes[inCount++] = toid;
+			isinput = true;
+			if (parameterTypes_list)
+				*parameterTypes_list = lappend_oid(*parameterTypes_list, toid);
+		}
+
+		/* handle output parameters */
+		if (fpmode != FUNC_PARAM_IN && fpmode != FUNC_PARAM_VARIADIC)
+		{
+			if (objtype == OBJECT_PROCEDURE)
+			{
+				/*
+				 * We disallow OUT-after-VARIADIC only for procedures.  While
+				 * such a case causes no confusion in ordinary function calls,
+				 * it would cause confusion in a CALL statement.
+				 */
+				if (varCount > 0)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+							 errmsg("VARIADIC parameter must be the last parameter")));
+				/* Procedures with output parameters always return RECORD */
+				*requiredResultType = RECORDOID;
+			}
+			else if (outCount == 0) /* save first output param's type */
+				*requiredResultType = toid;
+			outCount++;
+		}
+
+		if (fpmode == FUNC_PARAM_VARIADIC)
+		{
+			*variadicArgType = toid;
+			varCount++;
+			/* validate variadic parameter type */
+			switch (toid)
+			{
+				case ANYARRAYOID:
+				case ANYCOMPATIBLEARRAYOID:
+				case ANYOID:
+					/* okay */
+					break;
+				default:
+					if (!OidIsValid(get_element_type(toid)))
+						ereport(ERROR,
+								(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+								 errmsg("VARIADIC parameter must be an array")));
+					break;
+			}
+		}
+
+		allTypes[i] = ObjectIdGetDatum(toid);
+
+		paramModes[i] = CharGetDatum(fpmode);
+
+		if (fp->name && fp->name[0])
+		{
+			ListCell   *px;
+
+			/*
+			 * As of Postgres 9.0 we disallow using the same name for two
+			 * input or two output function parameters.  Depending on the
+			 * function's language, conflicting input and output names might
+			 * be bad too, but we leave it to the PL to complain if so.
+			 */
+			foreach(px, parameters)
+			{
+				FunctionParameter *prevfp = (FunctionParameter *) lfirst(px);
+				FunctionParameterMode prevfpmode;
+
+				if (prevfp == fp)
+					break;
+				/* as above, default mode is IN */
+				prevfpmode = prevfp->mode;
+				if (prevfpmode == FUNC_PARAM_DEFAULT)
+					prevfpmode = FUNC_PARAM_IN;
+				/* pure in doesn't conflict with pure out */
+				if ((fpmode == FUNC_PARAM_IN ||
+					 fpmode == FUNC_PARAM_VARIADIC) &&
+					(prevfpmode == FUNC_PARAM_OUT ||
+					 prevfpmode == FUNC_PARAM_TABLE))
+					continue;
+				if ((prevfpmode == FUNC_PARAM_IN ||
+					 prevfpmode == FUNC_PARAM_VARIADIC) &&
+					(fpmode == FUNC_PARAM_OUT ||
+					 fpmode == FUNC_PARAM_TABLE))
+					continue;
+				if (prevfp->name && prevfp->name[0] &&
+					strcmp(prevfp->name, fp->name) == 0)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+							 errmsg("parameter name \"%s\" used more than once",
+									fp->name)));
+			}
+
+			paramNames[i] = CStringGetTextDatum(fp->name);
+			have_names = true;
+		}
+
+		if (inParameterNames_list)
+			*inParameterNames_list = lappend(*inParameterNames_list, makeString(fp->name ? fp->name : pstrdup("")));
+
+		if (fp->defexpr)
+		{
+			Node	   *def;
+
+			if (!isinput)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("only input parameters can have default values")));
+
+			def = transformExpr(pstate, fp->defexpr,
+								EXPR_KIND_FUNCTION_DEFAULT);
+			def = coerce_to_specific_type(pstate, def, toid, "DEFAULT");
+			assign_expr_collations(pstate, def);
+
+			/*
+			 * Make sure no variables are referred to (this is probably dead
+			 * code now that add_missing_from is history).
+			 */
+			if (pstate->p_rtable != NIL ||
+				contain_var_clause(def))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
+						 errmsg("cannot use table references in parameter default value")));
+
+			/*
+			 * transformExpr() should have already rejected subqueries,
+			 * aggregates, and window functions, based on the EXPR_KIND_ for a
+			 * default expression.
+			 *
+			 * It can't return a set either --- but coerce_to_specific_type
+			 * already checked that for us.
+			 *
+			 * Note: the point of these restrictions is to ensure that an
+			 * expression that, on its face, hasn't got subplans, aggregates,
+			 * etc cannot suddenly have them after function default arguments
+			 * are inserted.
+			 */
+
+			*parameterDefaults = lappend(*parameterDefaults, def);
+			have_defaults = true;
+		}
+		else
+		{
+			if (isinput && have_defaults)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("input parameters after one with a default value must also have defaults")));
+
+			/*
+			 * For procedures, we also can't allow OUT parameters after one
+			 * with a default, because the same sort of confusion arises in a
+			 * CALL statement.
+			 */
+			if (objtype == OBJECT_PROCEDURE && have_defaults)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("procedure OUT parameters cannot appear after one with a default value")));
+		}
+
+		i++;
+	}
+
+	/* Now construct the proper outputs as needed */
+	*parameterTypes = buildoidvector(inTypes, inCount);
+
+	if (outCount > 0 || varCount > 0)
+	{
+		*allParameterTypes = construct_array_builtin(allTypes, parameterCount, OIDOID);
+		*parameterModes = construct_array_builtin(paramModes, parameterCount, CHAROID);
+		if (outCount > 1)
+			*requiredResultType = RECORDOID;
+		/* otherwise we set requiredResultType correctly above */
+	}
+	else
+	{
+		*allParameterTypes = NULL;
+		*parameterModes = NULL;
+	}
+
+	if (have_names)
+	{
+		for (i = 0; i < parameterCount; i++)
+		{
+			if (paramNames[i] == PointerGetDatum(NULL))
+				paramNames[i] = CStringGetTextDatum("");
+		}
+		*parameterNames = construct_array_builtin(paramNames, parameterCount, TEXTOID);
+	}
+	else
+		*parameterNames = NULL;
+}
+
+
+/*
+ * Recognize one of the options that can be passed to both CREATE
+ * FUNCTION and ALTER FUNCTION and return it via one of the out
+ * parameters. Returns true if the passed option was recognized. If
+ * the out parameter we were going to assign to points to non-NULL,
+ * raise a duplicate-clause error.  (We don't try to detect duplicate
+ * SET parameters though --- if you're redundant, the last one wins.)
+ */
+static bool
+compute_common_attribute(ParseState *pstate,
+						 bool is_procedure,
+						 DefElem *defel,
+						 DefElem **volatility_item,
+						 DefElem **strict_item,
+						 DefElem **security_item,
+						 DefElem **leakproof_item,
+						 List **set_items,
+						 DefElem **cost_item,
+						 DefElem **rows_item,
+						 DefElem **support_item,
+						 DefElem **parallel_item)
+{
+	if (strcmp(defel->defname, "volatility") == 0)
+	{
+		if (is_procedure)
+			goto procedure_error;
+		if (*volatility_item)
+			errorConflictingDefElem(defel, pstate);
+
+		*volatility_item = defel;
+	}
+	else if (strcmp(defel->defname, "strict") == 0)
+	{
+		if (is_procedure)
+			goto procedure_error;
+		if (*strict_item)
+			errorConflictingDefElem(defel, pstate);
+
+		*strict_item = defel;
+	}
+	else if (strcmp(defel->defname, "security") == 0)
+	{
+		if (*security_item)
+			errorConflictingDefElem(defel, pstate);
+
+		*security_item = defel;
+	}
+	else if (strcmp(defel->defname, "leakproof") == 0)
+	{
+		if (is_procedure)
+			goto procedure_error;
+		if (*leakproof_item)
+			errorConflictingDefElem(defel, pstate);
+
+		*leakproof_item = defel;
+	}
+	else if (strcmp(defel->defname, "set") == 0)
+	{
+		*set_items = lappend(*set_items, defel->arg);
+	}
+	else if (strcmp(defel->defname, "cost") == 0)
+	{
+		if (is_procedure)
+			goto procedure_error;
+		if (*cost_item)
+			errorConflictingDefElem(defel, pstate);
+
+		*cost_item = defel;
+	}
+	else if (strcmp(defel->defname, "rows") == 0)
+	{
+		if (is_procedure)
+			goto procedure_error;
+		if (*rows_item)
+			errorConflictingDefElem(defel, pstate);
+
+		*rows_item = defel;
+	}
+	else if (strcmp(defel->defname, "support") == 0)
+	{
+		if (is_procedure)
+			goto procedure_error;
+		if (*support_item)
+			errorConflictingDefElem(defel, pstate);
+
+		*support_item = defel;
+	}
+	else if (strcmp(defel->defname, "parallel") == 0)
+	{
+		if (is_procedure)
+			goto procedure_error;
+		if (*parallel_item)
+			errorConflictingDefElem(defel, pstate);
+
+		*parallel_item = defel;
+	}
+	else
+		return false;
+
+	/* Recognized an option */
+	return true;
+
+procedure_error:
+	ereport(ERROR,
+			(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+			 errmsg("invalid attribute in procedure definition"),
+			 parser_errposition(pstate, defel->location)));
+	return false;
+}
+
+static char
+interpret_func_volatility(DefElem *defel)
+{
+	char	   *str = strVal(defel->arg);
+
+	if (strcmp(str, "immutable") == 0)
+		return PROVOLATILE_IMMUTABLE;
+	else if (strcmp(str, "stable") == 0)
+		return PROVOLATILE_STABLE;
+	else if (strcmp(str, "volatile") == 0)
+		return PROVOLATILE_VOLATILE;
+	else
+	{
+		elog(ERROR, "invalid volatility \"%s\"", str);
+		return 0;				/* keep compiler quiet */
+	}
+}
+
+static char
+interpret_func_parallel(DefElem *defel)
+{
+	char	   *str = strVal(defel->arg);
+
+	if (strcmp(str, "safe") == 0)
+		return PROPARALLEL_SAFE;
+	else if (strcmp(str, "unsafe") == 0)
+		return PROPARALLEL_UNSAFE;
+	else if (strcmp(str, "restricted") == 0)
+		return PROPARALLEL_RESTRICTED;
+	else
+	{
+		ereport(ERROR,
+				(errcode(ERRCODE_SYNTAX_ERROR),
+				 errmsg("parameter \"parallel\" must be SAFE, RESTRICTED, or UNSAFE")));
+		return PROPARALLEL_UNSAFE;	/* keep compiler quiet */
+	}
+}
+
+/*
+ * Update a proconfig value according to a list of VariableSetStmt items.
+ *
+ * The input and result may be NULL to signify a null entry.
+ */
+static ArrayType *
+update_proconfig_value(ArrayType *a, List *set_items)
+{
+	ListCell   *l;
+
+	foreach(l, set_items)
+	{
+		VariableSetStmt *sstmt = lfirst_node(VariableSetStmt, l);
+
+		if (sstmt->kind == VAR_RESET_ALL)
+			a = NULL;
+		else
+		{
+			char	   *valuestr = ExtractSetVariableArgs(sstmt);
+
+			if (valuestr)
+				a = GUCArrayAdd(a, sstmt->name, valuestr);
+			else				/* RESET */
+				a = GUCArrayDelete(a, sstmt->name);
+		}
+	}
+
+	return a;
+}
+
+static Oid
+interpret_func_support(DefElem *defel)
+{
+	List	   *procName = defGetQualifiedName(defel);
+	Oid			procOid;
+	Oid			argList[1];
+
+	/*
+	 * Support functions always take one INTERNAL argument and return
+	 * INTERNAL.
+	 */
+	argList[0] = INTERNALOID;
+
+	procOid = LookupFuncName(procName, 1, argList, true);
+	if (!OidIsValid(procOid))
+		ereport(ERROR,
+				(errcode(ERRCODE_UNDEFINED_FUNCTION),
+				 errmsg("function %s does not exist",
+						func_signature_string(procName, 1, NIL, argList))));
+
+	if (get_func_rettype(procOid) != INTERNALOID)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+				 errmsg("support function %s must return type %s",
+						NameListToString(procName), "internal")));
+
+	/*
+	 * Someday we might want an ACL check here; but for now, we insist that
+	 * you be superuser to specify a support function, so privilege on the
+	 * support function is moot.
+	 */
+	if (!superuser())
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("must be superuser to specify a support function")));
+
+	return procOid;
+}
+
+
+/*
+ * Dissect the list of options assembled in gram.y into function
+ * attributes.
+ */
+static void
+compute_function_attributes(ParseState *pstate,
+							bool is_procedure,
+							List *options,
+							List **as,
+							char **language,
+							Node **transform,
+							bool *windowfunc_p,
+							char *volatility_p,
+							bool *strict_p,
+							bool *security_definer,
+							bool *leakproof_p,
+							ArrayType **proconfig,
+							float4 *procost,
+							float4 *prorows,
+							Oid *prosupport,
+							char *parallel_p)
+{
+	ListCell   *option;
+	DefElem    *as_item = NULL;
+	DefElem    *language_item = NULL;
+	DefElem    *transform_item = NULL;
+	DefElem    *windowfunc_item = NULL;
+	DefElem    *volatility_item = NULL;
+	DefElem    *strict_item = NULL;
+	DefElem    *security_item = NULL;
+	DefElem    *leakproof_item = NULL;
+	List	   *set_items = NIL;
+	DefElem    *cost_item = NULL;
+	DefElem    *rows_item = NULL;
+	DefElem    *support_item = NULL;
+	DefElem    *parallel_item = NULL;
+
+	foreach(option, options)
+	{
+		DefElem    *defel = (DefElem *) lfirst(option);
+
+		if (strcmp(defel->defname, "as") == 0)
+		{
+			if (as_item)
+				errorConflictingDefElem(defel, pstate);
+			as_item = defel;
+		}
+		else if (strcmp(defel->defname, "language") == 0)
+		{
+			if (language_item)
+				errorConflictingDefElem(defel, pstate);
+			language_item = defel;
+		}
+		else if (strcmp(defel->defname, "transform") == 0)
+		{
+			if (transform_item)
+				errorConflictingDefElem(defel, pstate);
+			transform_item = defel;
+		}
+		else if (strcmp(defel->defname, "window") == 0)
+		{
+			if (windowfunc_item)
+				errorConflictingDefElem(defel, pstate);
+			if (is_procedure)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("invalid attribute in procedure definition"),
+						 parser_errposition(pstate, defel->location)));
+			windowfunc_item = defel;
+		}
+		else if (compute_common_attribute(pstate,
+										  is_procedure,
+										  defel,
+										  &volatility_item,
+										  &strict_item,
+										  &security_item,
+										  &leakproof_item,
+										  &set_items,
+										  &cost_item,
+										  &rows_item,
+										  &support_item,
+										  &parallel_item))
+		{
+			/* recognized common option */
+			continue;
+		}
+		else
+			elog(ERROR, "option \"%s\" not recognized",
+				 defel->defname);
+	}
+
+	if (as_item)
+		*as = (List *) as_item->arg;
+	if (language_item)
+		*language = strVal(language_item->arg);
+	if (transform_item)
+		*transform = transform_item->arg;
+	if (windowfunc_item)
+		*windowfunc_p = boolVal(windowfunc_item->arg);
+	if (volatility_item)
+		*volatility_p = interpret_func_volatility(volatility_item);
+	if (strict_item)
+		*strict_p = boolVal(strict_item->arg);
+	if (security_item)
+		*security_definer = boolVal(security_item->arg);
+	if (leakproof_item)
+		*leakproof_p = boolVal(leakproof_item->arg);
+	if (set_items)
+		*proconfig = update_proconfig_value(NULL, set_items);
+	if (cost_item)
+	{
+		*procost = defGetNumeric(cost_item);
+		if (*procost <= 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("COST must be positive")));
+	}
+	if (rows_item)
+	{
+		*prorows = defGetNumeric(rows_item);
+		if (*prorows <= 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("ROWS must be positive")));
+	}
+	if (support_item)
+		*prosupport = interpret_func_support(support_item);
+	if (parallel_item)
+		*parallel_p = interpret_func_parallel(parallel_item);
+}
+
+
+/*
+ * For a dynamically linked C language object, the form of the clause is
+ *
+ *	   AS <object file name> [, <link symbol name> ]
+ *
+ * In all other cases
+ *
+ *	   AS <object reference, or sql code>
+ */
+static void
+interpret_AS_clause(Oid languageOid, const char *languageName,
+					char *funcname, List *as, Node *sql_body_in,
+					List *parameterTypes, List *inParameterNames,
+					char **prosrc_str_p, char **probin_str_p,
+					Node **sql_body_out,
+					const char *queryString)
+{
+	if (!sql_body_in && !as)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+				 errmsg("no function body specified")));
+
+	if (sql_body_in && as)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+				 errmsg("duplicate function body specified")));
+
+	if (sql_body_in && languageOid != SQLlanguageId)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+				 errmsg("inline SQL function body only valid for language SQL")));
+
+	*sql_body_out = NULL;
+
+	if (languageOid == ClanguageId)
+	{
+		/*
+		 * For "C" language, store the file name in probin and, when given,
+		 * the link symbol name in prosrc.  If link symbol is omitted,
+		 * substitute procedure name.  We also allow link symbol to be
+		 * specified as "-", since that was the habit in PG versions before
+		 * 8.4, and there might be dump files out there that don't translate
+		 * that back to "omitted".
+		 */
+		*probin_str_p = strVal(linitial(as));
+		if (list_length(as) == 1)
+			*prosrc_str_p = funcname;
+		else
+		{
+			*prosrc_str_p = strVal(lsecond(as));
+			if (strcmp(*prosrc_str_p, "-") == 0)
+				*prosrc_str_p = funcname;
+		}
+	}
+	else if (sql_body_in)
+	{
+		SQLFunctionParseInfoPtr pinfo;
+
+		pinfo = (SQLFunctionParseInfoPtr) palloc0(sizeof(SQLFunctionParseInfo));
+
+		pinfo->fname = funcname;
+		pinfo->nargs = list_length(parameterTypes);
+		pinfo->argtypes = (Oid *) palloc(pinfo->nargs * sizeof(Oid));
+		pinfo->argnames = (char **) palloc(pinfo->nargs * sizeof(char *));
+		for (int i = 0; i < list_length(parameterTypes); i++)
+		{
+			char	   *s = strVal(list_nth(inParameterNames, i));
+
+			pinfo->argtypes[i] = list_nth_oid(parameterTypes, i);
+			if (IsPolymorphicType(pinfo->argtypes[i]))
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+						 errmsg("SQL function with unquoted function body cannot have polymorphic arguments")));
+
+			if (s[0] != '\0')
+				pinfo->argnames[i] = s;
+			else
+				pinfo->argnames[i] = NULL;
+		}
+
+		if (IsA(sql_body_in, List))
+		{
+			List	   *stmts = linitial_node(List, castNode(List, sql_body_in));
+			ListCell   *lc;
+			List	   *transformed_stmts = NIL;
+
+			foreach(lc, stmts)
+			{
+				Node	   *stmt = lfirst(lc);
+				Query	   *q;
+				ParseState *pstate = make_parsestate(NULL);
+
+				pstate->p_sourcetext = queryString;
+				sql_fn_parser_setup(pstate, pinfo);
+				q = transformStmt(pstate, stmt);
+				if (q->commandType == CMD_UTILITY)
+					ereport(ERROR,
+							errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+							errmsg("%s is not yet supported in unquoted SQL function body",
+								   GetCommandTagName(CreateCommandTag(q->utilityStmt))));
+				transformed_stmts = lappend(transformed_stmts, q);
+				free_parsestate(pstate);
+			}
+
+			*sql_body_out = (Node *) list_make1(transformed_stmts);
+		}
+		else
+		{
+			Query	   *q;
+			ParseState *pstate = make_parsestate(NULL);
+
+			pstate->p_sourcetext = queryString;
+			sql_fn_parser_setup(pstate, pinfo);
+			q = transformStmt(pstate, sql_body_in);
+			if (q->commandType == CMD_UTILITY)
+				ereport(ERROR,
+						errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+						errmsg("%s is not yet supported in unquoted SQL function body",
+							   GetCommandTagName(CreateCommandTag(q->utilityStmt))));
+			free_parsestate(pstate);
+
+			*sql_body_out = (Node *) q;
+		}
+
+		/*
+		 * We must put something in prosrc.  For the moment, just record an
+		 * empty string.  It might be useful to store the original text of the
+		 * CREATE FUNCTION statement --- but to make actual use of that in
+		 * error reports, we'd also have to adjust readfuncs.c to not throw
+		 * away node location fields when reading prosqlbody.
+		 */
+		*prosrc_str_p = pstrdup("");
+
+		/* But we definitely don't need probin. */
+		*probin_str_p = NULL;
+	}
+	else
+	{
+		/* Everything else wants the given string in prosrc. */
+		*prosrc_str_p = strVal(linitial(as));
+		*probin_str_p = NULL;
+
+		if (list_length(as) != 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+					 errmsg("only one AS item needed for language \"%s\"",
+							languageName)));
+
+		if (languageOid == INTERNALlanguageId)
+		{
+			/*
+			 * In PostgreSQL versions before 6.5, the SQL name of the created
+			 * function could not be different from the internal name, and
+			 * "prosrc" wasn't used.  So there is code out there that does
+			 * CREATE FUNCTION xyz AS '' LANGUAGE internal. To preserve some
+			 * modicum of backwards compatibility, accept an empty "prosrc"
+			 * value as meaning the supplied SQL function name.
+			 */
+			if (strlen(*prosrc_str_p) == 0)
+				*prosrc_str_p = funcname;
+		}
+	}
+}
+
+
+/*
+ * CreateFunction
+ *	 Execute a CREATE FUNCTION (or CREATE PROCEDURE) utility statement.
+ */
+ObjectAddress
+CreateFunction(ParseState *pstate, CreateFunctionStmt *stmt)
+{
+	char	   *probin_str;
+	char	   *prosrc_str;
+	Node	   *prosqlbody;
+	Oid			prorettype;
+	bool		returnsSet;
+	char	   *language;
+	Oid			languageOid;
+	Oid			languageValidator;
+	Node	   *transformDefElem = NULL;
+	char	   *funcname;
+	Oid			namespaceId;
+	AclResult	aclresult;
+	oidvector  *parameterTypes;
+	List	   *parameterTypes_list = NIL;
+	ArrayType  *allParameterTypes;
+	ArrayType  *parameterModes;
+	ArrayType  *parameterNames;
+	List	   *inParameterNames_list = NIL;
+	List	   *parameterDefaults;
+	Oid			variadicArgType;
+	List	   *trftypes_list = NIL;
+	ArrayType  *trftypes;
+	Oid			requiredResultType;
+	bool		isWindowFunc,
+				isStrict,
+				security,
+				isLeakProof;
+	char		volatility;
+	ArrayType  *proconfig;
+	float4		procost;
+	float4		prorows;
+	Oid			prosupport;
+	HeapTuple	languageTuple;
+	Form_pg_language languageStruct;
+	List	   *as_clause;
+	char		parallel;
+
+	/* Convert list of names to a name and namespace */
+	namespaceId = QualifiedNameGetCreationNamespace(stmt->funcname,
+													&funcname);
+
+	/* Check we have creation rights in target namespace */
+	aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(), ACL_CREATE);
+	if (aclresult != ACLCHECK_OK)
+		aclcheck_error(aclresult, OBJECT_SCHEMA,
+					   get_namespace_name(namespaceId));
+
+	/* Set default attributes */
+	as_clause = NIL;
+	language = NULL;
+	isWindowFunc = false;
+	isStrict = false;
+	security = false;
+	isLeakProof = false;
+	volatility = PROVOLATILE_VOLATILE;
+	proconfig = NULL;
+	procost = -1;				/* indicates not set */
+	prorows = -1;				/* indicates not set */
+	prosupport = InvalidOid;
+	parallel = PROPARALLEL_UNSAFE;
+
+	/* Extract non-default attributes from stmt->options list */
+	compute_function_attributes(pstate,
+								stmt->is_procedure,
+								stmt->options,
+								&as_clause, &language, &transformDefElem,
+								&isWindowFunc, &volatility,
+								&isStrict, &security, &isLeakProof,
+								&proconfig, &procost, &prorows,
+								&prosupport, &parallel);
+
+	if (!language)
+	{
+		if (stmt->sql_body)
+			language = "sql";
+		else
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+					 errmsg("no language specified")));
+	}
+
+	/* Look up the language and validate permissions */
+	languageTuple = SearchSysCache1(LANGNAME, PointerGetDatum(language));
+	if (!HeapTupleIsValid(languageTuple))
+		ereport(ERROR,
+				(errcode(ERRCODE_UNDEFINED_OBJECT),
+				 errmsg("language \"%s\" does not exist", language),
+				 (extension_file_exists(language) ?
+				  errhint("Use CREATE EXTENSION to load the language into the database.") : 0)));
+
+	languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
+	languageOid = languageStruct->oid;
+
+	if (languageStruct->lanpltrusted)
+	{
+		/* if trusted language, need USAGE privilege */
+		aclresult = object_aclcheck(LanguageRelationId, languageOid, GetUserId(), ACL_USAGE);
+		if (aclresult != ACLCHECK_OK)
+			aclcheck_error(aclresult, OBJECT_LANGUAGE,
+						   NameStr(languageStruct->lanname));
+	}
+	else
+	{
+		/* if untrusted language, must be superuser */
+		if (!superuser())
+			aclcheck_error(ACLCHECK_NO_PRIV, OBJECT_LANGUAGE,
+						   NameStr(languageStruct->lanname));
+	}
+
+	languageValidator = languageStruct->lanvalidator;
+
+	ReleaseSysCache(languageTuple);
+
+	/*
+	 * Only superuser is allowed to create leakproof functions because
+	 * leakproof functions can see tuples which have not yet been filtered out
+	 * by security barrier views or row-level security policies.
+	 */
+	if (isLeakProof && !superuser())
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("only superuser can define a leakproof function")));
+
+	if (transformDefElem)
+	{
+		ListCell   *lc;
+
+		foreach(lc, castNode(List, transformDefElem))
+		{
+			Oid			typeid = typenameTypeId(NULL,
+												lfirst_node(TypeName, lc));
+			Oid			elt = get_base_element_type(typeid);
+
+			typeid = elt ? elt : typeid;
+
+			get_transform_oid(typeid, languageOid, false);
+			trftypes_list = lappend_oid(trftypes_list, typeid);
+		}
+	}
+
+	/*
+	 * Convert remaining parameters of CREATE to form wanted by
+	 * ProcedureCreate.
+	 */
+	interpret_function_parameter_list(pstate,
+									  stmt->parameters,
+									  languageOid,
+									  stmt->is_procedure ? OBJECT_PROCEDURE : OBJECT_FUNCTION,
+									  &parameterTypes,
+									  &parameterTypes_list,
+									  &allParameterTypes,
+									  &parameterModes,
+									  &parameterNames,
+									  &inParameterNames_list,
+									  &parameterDefaults,
+									  &variadicArgType,
+									  &requiredResultType);
+
+	if (stmt->is_procedure)
+	{
+		Assert(!stmt->returnType);
+		prorettype = requiredResultType ? requiredResultType : VOIDOID;
+		returnsSet = false;
+	}
+	else if (stmt->returnType)
+	{
+		/* explicit RETURNS clause */
+		compute_return_type(stmt->returnType, languageOid,
+							&prorettype, &returnsSet);
+		if (OidIsValid(requiredResultType) && prorettype != requiredResultType)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+					 errmsg("function result type must be %s because of OUT parameters",
+							format_type_be(requiredResultType))));
+	}
+	else if (OidIsValid(requiredResultType))
+	{
+		/* default RETURNS clause from OUT parameters */
+		prorettype = requiredResultType;
+		returnsSet = false;
+	}
+	else
+	{
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+				 errmsg("function result type must be specified")));
+		/* Alternative possibility: default to RETURNS VOID */
+		prorettype = VOIDOID;
+		returnsSet = false;
+	}
+
+	if (trftypes_list != NIL)
+	{
+		ListCell   *lc;
+		Datum	   *arr;
+		int			i;
+
+		arr = palloc(list_length(trftypes_list) * sizeof(Datum));
+		i = 0;
+		foreach(lc, trftypes_list)
+			arr[i++] = ObjectIdGetDatum(lfirst_oid(lc));
+		trftypes = construct_array_builtin(arr, list_length(trftypes_list), OIDOID);
+	}
+	else
+	{
+		/* store SQL NULL instead of empty array */
+		trftypes = NULL;
+	}
+
+	interpret_AS_clause(languageOid, language, funcname, as_clause, stmt->sql_body,
+						parameterTypes_list, inParameterNames_list,
+						&prosrc_str, &probin_str, &prosqlbody,
+						pstate->p_sourcetext);
+
+	/*
+	 * Set default values for COST and ROWS depending on other parameters;
+	 * reject ROWS if it's not returnsSet.  NB: pg_dump knows these default
+	 * values, keep it in sync if you change them.
+	 */
+	if (procost < 0)
+	{
+		/* SQL and PL-language functions are assumed more expensive */
+		if (languageOid == INTERNALlanguageId ||
+			languageOid == ClanguageId)
+			procost = 1;
+		else
+			procost = 100;
+	}
+	if (prorows < 0)
+	{
+		if (returnsSet)
+			prorows = 1000;
+		else
+			prorows = 0;		/* dummy value if not returnsSet */
+	}
+	else if (!returnsSet)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("ROWS is not applicable when function does not return a set")));
+
+	/*
+	 * And now that we have all the parameters, and know we're permitted to do
+	 * so, go ahead and create the function.
+	 */
+	return ProcedureCreate(funcname,
+						   namespaceId,
+						   stmt->replace,
+						   returnsSet,
+						   prorettype,
+						   GetUserId(),
+						   languageOid,
+						   languageValidator,
+						   prosrc_str,	/* converted to text later */
+						   probin_str,	/* converted to text later */
+						   prosqlbody,
+						   stmt->is_procedure ? PROKIND_PROCEDURE : (isWindowFunc ? PROKIND_WINDOW : PROKIND_FUNCTION),
+						   security,
+						   isLeakProof,
+						   isStrict,
+						   volatility,
+						   parallel,
+						   parameterTypes,
+						   PointerGetDatum(allParameterTypes),
+						   PointerGetDatum(parameterModes),
+						   PointerGetDatum(parameterNames),
+						   parameterDefaults,
+						   PointerGetDatum(trftypes),
+						   PointerGetDatum(proconfig),
+						   prosupport,
+						   procost,
+						   prorows);
+}
+
+/*
+ * Guts of function deletion.
+ *
+ * Note: this is also used for aggregate deletion, since the OIDs of
+ * both functions and aggregates point to pg_proc.
+ */
+void
+RemoveFunctionById(Oid funcOid)
+{
+	Relation	relation;
+	HeapTuple	tup;
+	char		prokind;
+
+	/*
+	 * Delete the pg_proc tuple.
+	 */
+	relation = table_open(ProcedureRelationId, RowExclusiveLock);
+
+	tup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcOid));
+	if (!HeapTupleIsValid(tup)) /* should not happen */
+		elog(ERROR, "cache lookup failed for function %u", funcOid);
+
+	prokind = ((Form_pg_proc) GETSTRUCT(tup))->prokind;
+
+	CatalogTupleDelete(relation, &tup->t_self);
+
+	ReleaseSysCache(tup);
+
+	table_close(relation, RowExclusiveLock);
+
+	pgstat_drop_function(funcOid);
+
+	/*
+	 * If there's a pg_aggregate tuple, delete that too.
+	 */
+	if (prokind == PROKIND_AGGREGATE)
+	{
+		relation = table_open(AggregateRelationId, RowExclusiveLock);
+
+		tup = SearchSysCache1(AGGFNOID, ObjectIdGetDatum(funcOid));
+		if (!HeapTupleIsValid(tup)) /* should not happen */
+			elog(ERROR, "cache lookup failed for pg_aggregate tuple for function %u", funcOid);
+
+		CatalogTupleDelete(relation, &tup->t_self);
+
+		ReleaseSysCache(tup);
+
+		table_close(relation, RowExclusiveLock);
+	}
+}
+
+/*
+ * Implements the ALTER FUNCTION utility command (except for the
+ * RENAME and OWNER clauses, which are handled as part of the generic
+ * ALTER framework).
+ */
+ObjectAddress
+AlterFunction(ParseState *pstate, AlterFunctionStmt *stmt)
+{
+	HeapTuple	tup;
+	Oid			funcOid;
+	Form_pg_proc procForm;
+	bool		is_procedure;
+	Relation	rel;
+	ListCell   *l;
+	DefElem    *volatility_item = NULL;
+	DefElem    *strict_item = NULL;
+	DefElem    *security_def_item = NULL;
+	DefElem    *leakproof_item = NULL;
+	List	   *set_items = NIL;
+	DefElem    *cost_item = NULL;
+	DefElem    *rows_item = NULL;
+	DefElem    *support_item = NULL;
+	DefElem    *parallel_item = NULL;
+	ObjectAddress address;
+
+	rel = table_open(ProcedureRelationId, RowExclusiveLock);
+
+	funcOid = LookupFuncWithArgs(stmt->objtype, stmt->func, false);
+
+	ObjectAddressSet(address, ProcedureRelationId, funcOid);
+
+	tup = SearchSysCacheCopy1(PROCOID, ObjectIdGetDatum(funcOid));
+	if (!HeapTupleIsValid(tup)) /* should not happen */
+		elog(ERROR, "cache lookup failed for function %u", funcOid);
+
+	procForm = (Form_pg_proc) GETSTRUCT(tup);
+
+	/* Permission check: must own function */
+	if (!object_ownercheck(ProcedureRelationId, funcOid, GetUserId()))
+		aclcheck_error(ACLCHECK_NOT_OWNER, stmt->objtype,
+					   NameListToString(stmt->func->objname));
+
+	if (procForm->prokind == PROKIND_AGGREGATE)
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("\"%s\" is an aggregate function",
+						NameListToString(stmt->func->objname))));
+
+	is_procedure = (procForm->prokind == PROKIND_PROCEDURE);
+
+	/* Examine requested actions. */
+	foreach(l, stmt->actions)
+	{
+		DefElem    *defel = (DefElem *) lfirst(l);
+
+		if (compute_common_attribute(pstate,
+									 is_procedure,
+									 defel,
+									 &volatility_item,
+									 &strict_item,
+									 &security_def_item,
+									 &leakproof_item,
+									 &set_items,
+									 &cost_item,
+									 &rows_item,
+									 &support_item,
+									 &parallel_item) == false)
+			elog(ERROR, "option \"%s\" not recognized", defel->defname);
+	}
+
+	if (volatility_item)
+		procForm->provolatile = interpret_func_volatility(volatility_item);
+	if (strict_item)
+		procForm->proisstrict = boolVal(strict_item->arg);
+	if (security_def_item)
+		procForm->prosecdef = boolVal(security_def_item->arg);
+	if (leakproof_item)
+	{
+		procForm->proleakproof = boolVal(leakproof_item->arg);
+		if (procForm->proleakproof && !superuser())
+			ereport(ERROR,
+					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+					 errmsg("only superuser can define a leakproof function")));
+	}
+	if (cost_item)
+	{
+		procForm->procost = defGetNumeric(cost_item);
+		if (procForm->procost <= 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("COST must be positive")));
+	}
+	if (rows_item)
+	{
+		procForm->prorows = defGetNumeric(rows_item);
+		if (procForm->prorows <= 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("ROWS must be positive")));
+		if (!procForm->proretset)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("ROWS is not applicable when function does not return a set")));
+	}
+	if (support_item)
+	{
+		/* interpret_func_support handles the privilege check */
+		Oid			newsupport = interpret_func_support(support_item);
+
+		/* Add or replace dependency on support function */
+		if (OidIsValid(procForm->prosupport))
+			changeDependencyFor(ProcedureRelationId, funcOid,
+								ProcedureRelationId, procForm->prosupport,
+								newsupport);
+		else
+		{
+			ObjectAddress referenced;
+
+			referenced.classId = ProcedureRelationId;
+			referenced.objectId = newsupport;
+			referenced.objectSubId = 0;
+			recordDependencyOn(&address, &referenced, DEPENDENCY_NORMAL);
+		}
+
+		procForm->prosupport = newsupport;
+	}
+	if (parallel_item)
+		procForm->proparallel = interpret_func_parallel(parallel_item);
+	if (set_items)
+	{
+		Datum		datum;
+		bool		isnull;
+		ArrayType  *a;
+		Datum		repl_val[Natts_pg_proc];
+		bool		repl_null[Natts_pg_proc];
+		bool		repl_repl[Natts_pg_proc];
+
+		/* extract existing proconfig setting */
+		datum = SysCacheGetAttr(PROCOID, tup, Anum_pg_proc_proconfig, &isnull);
+		a = isnull ? NULL : DatumGetArrayTypeP(datum);
+
+		/* update according to each SET or RESET item, left to right */
+		a = update_proconfig_value(a, set_items);
+
+		/* update the tuple */
+		memset(repl_repl, false, sizeof(repl_repl));
+		repl_repl[Anum_pg_proc_proconfig - 1] = true;
+
+		if (a == NULL)
+		{
+			repl_val[Anum_pg_proc_proconfig - 1] = (Datum) 0;
+			repl_null[Anum_pg_proc_proconfig - 1] = true;
+		}
+		else
+		{
+			repl_val[Anum_pg_proc_proconfig - 1] = PointerGetDatum(a);
+			repl_null[Anum_pg_proc_proconfig - 1] = false;
+		}
+
+		tup = heap_modify_tuple(tup, RelationGetDescr(rel),
+								repl_val, repl_null, repl_repl);
+	}
+	/* DO NOT put more touches of procForm below here; it's now dangling. */
+
+	/* Do the update */
+	CatalogTupleUpdate(rel, &tup->t_self, tup);
+
+	InvokeObjectPostAlterHook(ProcedureRelationId, funcOid, 0);
+
+	table_close(rel, NoLock);
+	heap_freetuple(tup);
+
+	return address;
+}
+
+
+/*
+ * CREATE CAST
+ */
+ObjectAddress
+CreateCast(CreateCastStmt *stmt)
+{
+	Oid			sourcetypeid;
+	Oid			targettypeid;
+	char		sourcetyptype;
+	char		targettyptype;
+	Oid			funcid;
+	Oid			incastid = InvalidOid;
+	Oid			outcastid = InvalidOid;
+	int			nargs;
+	char		castcontext;
+	char		castmethod;
+	HeapTuple	tuple;
+	AclResult	aclresult;
+	ObjectAddress myself;
+
+	sourcetypeid = typenameTypeId(NULL, stmt->sourcetype);
+	targettypeid = typenameTypeId(NULL, stmt->targettype);
+	sourcetyptype = get_typtype(sourcetypeid);
+	targettyptype = get_typtype(targettypeid);
+
+	/* No pseudo-types allowed */
+	if (sourcetyptype == TYPTYPE_PSEUDO)
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("source data type %s is a pseudo-type",
+						TypeNameToString(stmt->sourcetype))));
+
+	if (targettyptype == TYPTYPE_PSEUDO)
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("target data type %s is a pseudo-type",
+						TypeNameToString(stmt->targettype))));
+
+	/* Permission check */
+	if (!object_ownercheck(TypeRelationId, sourcetypeid, GetUserId())
+		&& !object_ownercheck(TypeRelationId, targettypeid, GetUserId()))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("must be owner of type %s or type %s",
+						format_type_be(sourcetypeid),
+						format_type_be(targettypeid))));
+
+	aclresult = object_aclcheck(TypeRelationId, sourcetypeid, GetUserId(), ACL_USAGE);
+	if (aclresult != ACLCHECK_OK)
+		aclcheck_error_type(aclresult, sourcetypeid);
+
+	aclresult = object_aclcheck(TypeRelationId, targettypeid, GetUserId(), ACL_USAGE);
+	if (aclresult != ACLCHECK_OK)
+		aclcheck_error_type(aclresult, targettypeid);
+
+	/* Domains are allowed for historical reasons, but we warn */
+	if (sourcetyptype == TYPTYPE_DOMAIN)
+		ereport(WARNING,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("cast will be ignored because the source data type is a domain")));
+
+	else if (targettyptype == TYPTYPE_DOMAIN)
+		ereport(WARNING,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("cast will be ignored because the target data type is a domain")));
+
+	/* Determine the cast method */
+	if (stmt->func != NULL)
+		castmethod = COERCION_METHOD_FUNCTION;
+	else if (stmt->inout)
+		castmethod = COERCION_METHOD_INOUT;
+	else
+		castmethod = COERCION_METHOD_BINARY;
+
+	if (castmethod == COERCION_METHOD_FUNCTION)
+	{
+		Form_pg_proc procstruct;
+
+		funcid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->func, false);
+
+		tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for function %u", funcid);
+
+		procstruct = (Form_pg_proc) GETSTRUCT(tuple);
+		nargs = procstruct->pronargs;
+		if (nargs < 1 || nargs > 3)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("cast function must take one to three arguments")));
+		if (!IsBinaryCoercibleWithCast(sourcetypeid,
+									   procstruct->proargtypes.values[0],
+									   &incastid))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("argument of cast function must match or be binary-coercible from source data type")));
+		if (nargs > 1 && procstruct->proargtypes.values[1] != INT4OID)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("second argument of cast function must be type %s",
+							"integer")));
+		if (nargs > 2 && procstruct->proargtypes.values[2] != BOOLOID)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("third argument of cast function must be type %s",
+							"boolean")));
+		if (!IsBinaryCoercibleWithCast(procstruct->prorettype,
+									   targettypeid,
+									   &outcastid))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("return data type of cast function must match or be binary-coercible to target data type")));
+
+		/*
+		 * Restricting the volatility of a cast function may or may not be a
+		 * good idea in the abstract, but it definitely breaks many old
+		 * user-defined types.  Disable this check --- tgl 2/1/03
+		 */
+#ifdef NOT_USED
+		if (procstruct->provolatile == PROVOLATILE_VOLATILE)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("cast function must not be volatile")));
+#endif
+		if (procstruct->prokind != PROKIND_FUNCTION)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("cast function must be a normal function")));
+		if (procstruct->proretset)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("cast function must not return a set")));
+
+		ReleaseSysCache(tuple);
+	}
+	else
+	{
+		funcid = InvalidOid;
+		nargs = 0;
+	}
+
+	if (castmethod == COERCION_METHOD_BINARY)
+	{
+		int16		typ1len;
+		int16		typ2len;
+		bool		typ1byval;
+		bool		typ2byval;
+		char		typ1align;
+		char		typ2align;
+
+		/*
+		 * Must be superuser to create binary-compatible casts, since
+		 * erroneous casts can easily crash the backend.
+		 */
+		if (!superuser())
+			ereport(ERROR,
+					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+					 errmsg("must be superuser to create a cast WITHOUT FUNCTION")));
+
+		/*
+		 * Also, insist that the types match as to size, alignment, and
+		 * pass-by-value attributes; this provides at least a crude check that
+		 * they have similar representations.  A pair of types that fail this
+		 * test should certainly not be equated.
+		 */
+		get_typlenbyvalalign(sourcetypeid, &typ1len, &typ1byval, &typ1align);
+		get_typlenbyvalalign(targettypeid, &typ2len, &typ2byval, &typ2align);
+		if (typ1len != typ2len ||
+			typ1byval != typ2byval ||
+			typ1align != typ2align)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("source and target data types are not physically compatible")));
+
+		/*
+		 * We know that composite, enum and array types are never binary-
+		 * compatible with each other.  They all have OIDs embedded in them.
+		 *
+		 * Theoretically you could build a user-defined base type that is
+		 * binary-compatible with a composite, enum, or array type.  But we
+		 * disallow that too, as in practice such a cast is surely a mistake.
+		 * You can always work around that by writing a cast function.
+		 */
+		if (sourcetyptype == TYPTYPE_COMPOSITE ||
+			targettyptype == TYPTYPE_COMPOSITE)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("composite data types are not binary-compatible")));
+
+		if (sourcetyptype == TYPTYPE_ENUM ||
+			targettyptype == TYPTYPE_ENUM)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("enum data types are not binary-compatible")));
+
+		if (OidIsValid(get_element_type(sourcetypeid)) ||
+			OidIsValid(get_element_type(targettypeid)))
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("array data types are not binary-compatible")));
+
+		/*
+		 * We also disallow creating binary-compatibility casts involving
+		 * domains.  Casting from a domain to its base type is already
+		 * allowed, and casting the other way ought to go through domain
+		 * coercion to permit constraint checking.  Again, if you're intent on
+		 * having your own semantics for that, create a no-op cast function.
+		 *
+		 * NOTE: if we were to relax this, the above checks for composites
+		 * etc. would have to be modified to look through domains to their
+		 * base types.
+		 */
+		if (sourcetyptype == TYPTYPE_DOMAIN ||
+			targettyptype == TYPTYPE_DOMAIN)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("domain data types must not be marked binary-compatible")));
+	}
+
+	/*
+	 * Allow source and target types to be same only for length coercion
+	 * functions.  We assume a multi-arg function does length coercion.
+	 */
+	if (sourcetypeid == targettypeid && nargs < 2)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+				 errmsg("source data type and target data type are the same")));
+
+	/* convert CoercionContext enum to char value for castcontext */
+	switch (stmt->context)
+	{
+		case COERCION_IMPLICIT:
+			castcontext = COERCION_CODE_IMPLICIT;
+			break;
+		case COERCION_ASSIGNMENT:
+			castcontext = COERCION_CODE_ASSIGNMENT;
+			break;
+			/* COERCION_PLPGSQL is intentionally not covered here */
+		case COERCION_EXPLICIT:
+			castcontext = COERCION_CODE_EXPLICIT;
+			break;
+		default:
+			elog(ERROR, "unrecognized CoercionContext: %d", stmt->context);
+			castcontext = 0;	/* keep compiler quiet */
+			break;
+	}
+
+	myself = CastCreate(sourcetypeid, targettypeid, funcid, incastid, outcastid,
+						castcontext, castmethod, DEPENDENCY_NORMAL);
+	return myself;
+}
+
+
+static void
+check_transform_function(Form_pg_proc procstruct)
+{
+	if (procstruct->provolatile == PROVOLATILE_VOLATILE)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+				 errmsg("transform function must not be volatile")));
+	if (procstruct->prokind != PROKIND_FUNCTION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+				 errmsg("transform function must be a normal function")));
+	if (procstruct->proretset)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+				 errmsg("transform function must not return a set")));
+	if (procstruct->pronargs != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+				 errmsg("transform function must take one argument")));
+	if (procstruct->proargtypes.values[0] != INTERNALOID)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+				 errmsg("first argument of transform function must be type %s",
+						"internal")));
+}
+
+
+/*
+ * CREATE TRANSFORM
+ */
+ObjectAddress
+CreateTransform(CreateTransformStmt *stmt)
+{
+	Oid			typeid;
+	char		typtype;
+	Oid			langid;
+	Oid			fromsqlfuncid;
+	Oid			tosqlfuncid;
+	AclResult	aclresult;
+	Form_pg_proc procstruct;
+	Datum		values[Natts_pg_transform];
+	bool		nulls[Natts_pg_transform] = {0};
+	bool		replaces[Natts_pg_transform] = {0};
+	Oid			transformid;
+	HeapTuple	tuple;
+	HeapTuple	newtuple;
+	Relation	relation;
+	ObjectAddress myself,
+				referenced;
+	ObjectAddresses *addrs;
+	bool		is_replace;
+
+	/*
+	 * Get the type
+	 */
+	typeid = typenameTypeId(NULL, stmt->type_name);
+	typtype = get_typtype(typeid);
+
+	if (typtype == TYPTYPE_PSEUDO)
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("data type %s is a pseudo-type",
+						TypeNameToString(stmt->type_name))));
+
+	if (typtype == TYPTYPE_DOMAIN)
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("data type %s is a domain",
+						TypeNameToString(stmt->type_name))));
+
+	if (!object_ownercheck(TypeRelationId, typeid, GetUserId()))
+		aclcheck_error_type(ACLCHECK_NOT_OWNER, typeid);
+
+	aclresult = object_aclcheck(TypeRelationId, typeid, GetUserId(), ACL_USAGE);
+	if (aclresult != ACLCHECK_OK)
+		aclcheck_error_type(aclresult, typeid);
+
+	/*
+	 * Get the language
+	 */
+	langid = get_language_oid(stmt->lang, false);
+
+	aclresult = object_aclcheck(LanguageRelationId, langid, GetUserId(), ACL_USAGE);
+	if (aclresult != ACLCHECK_OK)
+		aclcheck_error(aclresult, OBJECT_LANGUAGE, stmt->lang);
+
+	/*
+	 * Get the functions
+	 */
+	if (stmt->fromsql)
+	{
+		fromsqlfuncid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->fromsql, false);
+
+		if (!object_ownercheck(ProcedureRelationId, fromsqlfuncid, GetUserId()))
+			aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->fromsql->objname));
+
+		aclresult = object_aclcheck(ProcedureRelationId, fromsqlfuncid, GetUserId(), ACL_EXECUTE);
+		if (aclresult != ACLCHECK_OK)
+			aclcheck_error(aclresult, OBJECT_FUNCTION, NameListToString(stmt->fromsql->objname));
+
+		tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(fromsqlfuncid));
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for function %u", fromsqlfuncid);
+		procstruct = (Form_pg_proc) GETSTRUCT(tuple);
+		if (procstruct->prorettype != INTERNALOID)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("return data type of FROM SQL function must be %s",
+							"internal")));
+		check_transform_function(procstruct);
+		ReleaseSysCache(tuple);
+	}
+	else
+		fromsqlfuncid = InvalidOid;
+
+	if (stmt->tosql)
+	{
+		tosqlfuncid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->tosql, false);
+
+		if (!object_ownercheck(ProcedureRelationId, tosqlfuncid, GetUserId()))
+			aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->tosql->objname));
+
+		aclresult = object_aclcheck(ProcedureRelationId, tosqlfuncid, GetUserId(), ACL_EXECUTE);
+		if (aclresult != ACLCHECK_OK)
+			aclcheck_error(aclresult, OBJECT_FUNCTION, NameListToString(stmt->tosql->objname));
+
+		tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(tosqlfuncid));
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for function %u", tosqlfuncid);
+		procstruct = (Form_pg_proc) GETSTRUCT(tuple);
+		if (procstruct->prorettype != typeid)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+					 errmsg("return data type of TO SQL function must be the transform data type")));
+		check_transform_function(procstruct);
+		ReleaseSysCache(tuple);
+	}
+	else
+		tosqlfuncid = InvalidOid;
+
+	/*
+	 * Ready to go
+	 */
+	values[Anum_pg_transform_trftype - 1] = ObjectIdGetDatum(typeid);
+	values[Anum_pg_transform_trflang - 1] = ObjectIdGetDatum(langid);
+	values[Anum_pg_transform_trffromsql - 1] = ObjectIdGetDatum(fromsqlfuncid);
+	values[Anum_pg_transform_trftosql - 1] = ObjectIdGetDatum(tosqlfuncid);
+
+	relation = table_open(TransformRelationId, RowExclusiveLock);
+
+	tuple = SearchSysCache2(TRFTYPELANG,
+							ObjectIdGetDatum(typeid),
+							ObjectIdGetDatum(langid));
+	if (HeapTupleIsValid(tuple))
+	{
+		Form_pg_transform form = (Form_pg_transform) GETSTRUCT(tuple);
+
+		if (!stmt->replace)
+			ereport(ERROR,
+					(errcode(ERRCODE_DUPLICATE_OBJECT),
+					 errmsg("transform for type %s language \"%s\" already exists",
+							format_type_be(typeid),
+							stmt->lang)));
+
+		replaces[Anum_pg_transform_trffromsql - 1] = true;
+		replaces[Anum_pg_transform_trftosql - 1] = true;
+
+		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values, nulls, replaces);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
+
+		transformid = form->oid;
+		ReleaseSysCache(tuple);
+		is_replace = true;
+	}
+	else
+	{
+		transformid = GetNewOidWithIndex(relation, TransformOidIndexId,
+										 Anum_pg_transform_oid);
+		values[Anum_pg_transform_oid - 1] = ObjectIdGetDatum(transformid);
+		newtuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
+		CatalogTupleInsert(relation, newtuple);
+		is_replace = false;
+	}
+
+	if (is_replace)
+		deleteDependencyRecordsFor(TransformRelationId, transformid, true);
+
+	addrs = new_object_addresses();
+
+	/* make dependency entries */
+	ObjectAddressSet(myself, TransformRelationId, transformid);
+
+	/* dependency on language */
+	ObjectAddressSet(referenced, LanguageRelationId, langid);
+	add_exact_object_address(&referenced, addrs);
+
+	/* dependency on type */
+	ObjectAddressSet(referenced, TypeRelationId, typeid);
+	add_exact_object_address(&referenced, addrs);
+
+	/* dependencies on functions */
+	if (OidIsValid(fromsqlfuncid))
+	{
+		ObjectAddressSet(referenced, ProcedureRelationId, fromsqlfuncid);
+		add_exact_object_address(&referenced, addrs);
+	}
+	if (OidIsValid(tosqlfuncid))
+	{
+		ObjectAddressSet(referenced, ProcedureRelationId, tosqlfuncid);
+		add_exact_object_address(&referenced, addrs);
+	}
+
+	record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
+	free_object_addresses(addrs);
+
+	/* dependency on extension */
+	recordDependencyOnCurrentExtension(&myself, is_replace);
+
+	/* Post creation hook for new transform */
+	InvokeObjectPostCreateHook(TransformRelationId, transformid, 0);
+
+	heap_freetuple(newtuple);
+
+	table_close(relation, RowExclusiveLock);
+
+	return myself;
+}
+
+
+/*
+ * get_transform_oid - given type OID and language OID, look up a transform OID
+ *
+ * If missing_ok is false, throw an error if the transform is not found.  If
+ * true, just return InvalidOid.
+ */
+Oid
+get_transform_oid(Oid type_id, Oid lang_id, bool missing_ok)
+{
+	Oid			oid;
+
+	oid = GetSysCacheOid2(TRFTYPELANG, Anum_pg_transform_oid,
+						  ObjectIdGetDatum(type_id),
+						  ObjectIdGetDatum(lang_id));
+	if (!OidIsValid(oid) && !missing_ok)
+		ereport(ERROR,
+				(errcode(ERRCODE_UNDEFINED_OBJECT),
+				 errmsg("transform for type %s language \"%s\" does not exist",
+						format_type_be(type_id),
+						get_language_name(lang_id, false))));
+	return oid;
+}
+
+
+/*
+ * Subroutine for ALTER FUNCTION/AGGREGATE SET SCHEMA/RENAME
+ *
+ * Is there a function with the given name and signature already in the given
+ * namespace?  If so, raise an appropriate error message.
+ */
+void
+IsThereFunctionInNamespace(const char *proname, int pronargs,
+						   oidvector *proargtypes, Oid nspOid)
+{
+	/* check for duplicate name (more friendly than unique-index failure) */
+	if (SearchSysCacheExists3(PROCNAMEARGSNSP,
+							  CStringGetDatum(proname),
+							  PointerGetDatum(proargtypes),
+							  ObjectIdGetDatum(nspOid)))
+		ereport(ERROR,
+				(errcode(ERRCODE_DUPLICATE_FUNCTION),
+				 errmsg("function %s already exists in schema \"%s\"",
+						funcname_signature_string(proname, pronargs,
+												  NIL, proargtypes->values),
+						get_namespace_name(nspOid))));
+}
+
+/*
+ * ExecuteDoStmt
+ *		Execute inline procedural-language code
+ *
+ * See at ExecuteCallStmt() about the atomic argument.
+ */
+void
+ExecuteDoStmt(ParseState *pstate, DoStmt *stmt, bool atomic)
+{
+	InlineCodeBlock *codeblock = makeNode(InlineCodeBlock);
+	ListCell   *arg;
+	DefElem    *as_item = NULL;
+	DefElem    *language_item = NULL;
+	char	   *language;
+	Oid			laninline;
+	HeapTuple	languageTuple;
+	Form_pg_language languageStruct;
+
+	/* Process options we got from gram.y */
+	foreach(arg, stmt->args)
+	{
+		DefElem    *defel = (DefElem *) lfirst(arg);
+
+		if (strcmp(defel->defname, "as") == 0)
+		{
+			if (as_item)
+				errorConflictingDefElem(defel, pstate);
+			as_item = defel;
+		}
+		else if (strcmp(defel->defname, "language") == 0)
+		{
+			if (language_item)
+				errorConflictingDefElem(defel, pstate);
+			language_item = defel;
+		}
+		else
+			elog(ERROR, "option \"%s\" not recognized",
+				 defel->defname);
+	}
+
+	if (as_item)
+		codeblock->source_text = strVal(as_item->arg);
+	else
+		ereport(ERROR,
+				(errcode(ERRCODE_SYNTAX_ERROR),
+				 errmsg("no inline code specified")));
+
+	/* if LANGUAGE option wasn't specified, use the default */
+	if (language_item)
+		language = strVal(language_item->arg);
+	else
+		language = "plpgsql";
+
+	/* Look up the language and validate permissions */
+	languageTuple = SearchSysCache1(LANGNAME, PointerGetDatum(language));
+	if (!HeapTupleIsValid(languageTuple))
+		ereport(ERROR,
+				(errcode(ERRCODE_UNDEFINED_OBJECT),
+				 errmsg("language \"%s\" does not exist", language),
+				 (extension_file_exists(language) ?
+				  errhint("Use CREATE EXTENSION to load the language into the database.") : 0)));
+
+	languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
+	codeblock->langOid = languageStruct->oid;
+	codeblock->langIsTrusted = languageStruct->lanpltrusted;
+	codeblock->atomic = atomic;
+
+	if (languageStruct->lanpltrusted)
+	{
+		/* if trusted language, need USAGE privilege */
+		AclResult	aclresult;
+
+		aclresult = object_aclcheck(LanguageRelationId, codeblock->langOid, GetUserId(),
+									ACL_USAGE);
+		if (aclresult != ACLCHECK_OK)
+			aclcheck_error(aclresult, OBJECT_LANGUAGE,
+						   NameStr(languageStruct->lanname));
+	}
+	else
+	{
+		/* if untrusted language, must be superuser */
+		if (!superuser())
+			aclcheck_error(ACLCHECK_NO_PRIV, OBJECT_LANGUAGE,
+						   NameStr(languageStruct->lanname));
+	}
+
+	/* get the handler function's OID */
+	laninline = languageStruct->laninline;
+	if (!OidIsValid(laninline))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("language \"%s\" does not support inline code execution",
+						NameStr(languageStruct->lanname))));
+
+	ReleaseSysCache(languageTuple);
+
+	/* execute the inline handler */
+	OidFunctionCall1(laninline, PointerGetDatum(codeblock));
+}
+
+/*
+ * Execute CALL statement
+ *
+ * Inside a top-level CALL statement, transaction-terminating commands such as
+ * COMMIT or a PL-specific equivalent are allowed.  The terminology in the SQL
+ * standard is that CALL establishes a non-atomic execution context.  Most
+ * other commands establish an atomic execution context, in which transaction
+ * control actions are not allowed.  If there are nested executions of CALL,
+ * we want to track the execution context recursively, so that the nested
+ * CALLs can also do transaction control.  Note, however, that for example in
+ * CALL -> SELECT -> CALL, the second call cannot do transaction control,
+ * because the SELECT in between establishes an atomic execution context.
+ *
+ * So when ExecuteCallStmt() is called from the top level, we pass in atomic =
+ * false (recall that that means transactions = yes).  We then create a
+ * CallContext node with content atomic = false, which is passed in the
+ * fcinfo->context field to the procedure invocation.  The language
+ * implementation should then take appropriate measures to allow or prevent
+ * transaction commands based on that information, e.g., call
+ * SPI_connect_ext(SPI_OPT_NONATOMIC).  The language should also pass on the
+ * atomic flag to any nested invocations to CALL.
+ *
+ * The expression data structures and execution context that we create
+ * within this function are children of the portalContext of the Portal
+ * that the CALL utility statement runs in.  Therefore, any pass-by-ref
+ * values that we're passing to the procedure will survive transaction
+ * commits that might occur inside the procedure.
+ */
+void
+ExecuteCallStmt(CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver *dest)
+{
+	LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);
+	ListCell   *lc;
+	FuncExpr   *fexpr;
+	int			nargs;
+	int			i;
+	AclResult	aclresult;
+	FmgrInfo	flinfo;
+	CallContext *callcontext;
+	EState	   *estate;
+	ExprContext *econtext;
+	HeapTuple	tp;
+	PgStat_FunctionCallUsage fcusage;
+	Datum		retval;
+
+	fexpr = stmt->funcexpr;
+	Assert(fexpr);
+	Assert(IsA(fexpr, FuncExpr));
+
+	aclresult = object_aclcheck(ProcedureRelationId, fexpr->funcid, GetUserId(), ACL_EXECUTE);
+	if (aclresult != ACLCHECK_OK)
+		aclcheck_error(aclresult, OBJECT_PROCEDURE, get_func_name(fexpr->funcid));
+
+	/* Prep the context object we'll pass to the procedure */
+	callcontext = makeNode(CallContext);
+	callcontext->atomic = atomic;
+
+	tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(fexpr->funcid));
+	if (!HeapTupleIsValid(tp))
+		elog(ERROR, "cache lookup failed for function %u", fexpr->funcid);
+
+	/*
+	 * If proconfig is set we can't allow transaction commands because of the
+	 * way the GUC stacking works: The transaction boundary would have to pop
+	 * the proconfig setting off the stack.  That restriction could be lifted
+	 * by redesigning the GUC nesting mechanism a bit.
+	 */
+	if (!heap_attisnull(tp, Anum_pg_proc_proconfig, NULL))
+		callcontext->atomic = true;
+
+	/*
+	 * In security definer procedures, we can't allow transaction commands.
+	 * StartTransaction() insists that the security context stack is empty,
+	 * and AbortTransaction() resets the security context.  This could be
+	 * reorganized, but right now it doesn't work.
+	 */
+	if (((Form_pg_proc) GETSTRUCT(tp))->prosecdef)
+		callcontext->atomic = true;
+
+	ReleaseSysCache(tp);
+
+	/* safety check; see ExecInitFunc() */
+	nargs = list_length(fexpr->args);
+	if (nargs > FUNC_MAX_ARGS)
+		ereport(ERROR,
+				(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
+				 errmsg_plural("cannot pass more than %d argument to a procedure",
+							   "cannot pass more than %d arguments to a procedure",
+							   FUNC_MAX_ARGS,
+							   FUNC_MAX_ARGS)));
+
+	/* Initialize function call structure */
+	InvokeFunctionExecuteHook(fexpr->funcid);
+	fmgr_info(fexpr->funcid, &flinfo);
+	fmgr_info_set_expr((Node *) fexpr, &flinfo);
+	InitFunctionCallInfoData(*fcinfo, &flinfo, nargs, fexpr->inputcollid,
+							 (Node *) callcontext, NULL);
+
+	/*
+	 * Evaluate procedure arguments inside a suitable execution context.  Note
+	 * we can't free this context till the procedure returns.
+	 */
+	estate = CreateExecutorState();
+	estate->es_param_list_info = params;
+	econtext = CreateExprContext(estate);
+
+	/*
+	 * If we're called in non-atomic context, we also have to ensure that the
+	 * argument expressions run with an up-to-date snapshot.  Our caller will
+	 * have provided a current snapshot in atomic contexts, but not in
+	 * non-atomic contexts, because the possibility of a COMMIT/ROLLBACK
+	 * destroying the snapshot makes higher-level management too complicated.
+	 */
+	if (!atomic)
+		PushActiveSnapshot(GetTransactionSnapshot());
+
+	i = 0;
+	foreach(lc, fexpr->args)
+	{
+		ExprState  *exprstate;
+		Datum		val;
+		bool		isnull;
+
+		exprstate = ExecPrepareExpr(lfirst(lc), estate);
+
+		val = ExecEvalExprSwitchContext(exprstate, econtext, &isnull);
+
+		fcinfo->args[i].value = val;
+		fcinfo->args[i].isnull = isnull;
+
+		i++;
+	}
+
+	/* Get rid of temporary snapshot for arguments, if we made one */
+	if (!atomic)
+		PopActiveSnapshot();
+
+	/* Here we actually call the procedure */
+	pgstat_init_function_usage(fcinfo, &fcusage);
+	retval = FunctionCallInvoke(fcinfo);
+	pgstat_end_function_usage(&fcusage, true);
+
+	/* Handle the procedure's outputs */
+	if (fexpr->funcresulttype == VOIDOID)
+	{
+		/* do nothing */
+	}
+	else if (fexpr->funcresulttype == RECORDOID)
+	{
+		/* send tuple to client */
+		HeapTupleHeader td;
+		Oid			tupType;
+		int32		tupTypmod;
+		TupleDesc	retdesc;
+		HeapTupleData rettupdata;
+		TupOutputState *tstate;
+		TupleTableSlot *slot;
+
+		if (fcinfo->isnull)
+			elog(ERROR, "procedure returned null record");
+
+		/*
+		 * Ensure there's an active snapshot whilst we execute whatever's
+		 * involved here.  Note that this is *not* sufficient to make the
+		 * world safe for TOAST pointers to be included in the returned data:
+		 * the referenced data could have gone away while we didn't hold a
+		 * snapshot.  Hence, it's incumbent on PLs that can do COMMIT/ROLLBACK
+		 * to not return TOAST pointers, unless those pointers were fetched
+		 * after the last COMMIT/ROLLBACK in the procedure.
+		 *
+		 * XXX that is a really nasty, hard-to-test requirement.  Is there a
+		 * way to remove it?
+		 */
+		EnsurePortalSnapshotExists();
+
+		td = DatumGetHeapTupleHeader(retval);
+		tupType = HeapTupleHeaderGetTypeId(td);
+		tupTypmod = HeapTupleHeaderGetTypMod(td);
+		retdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
+
+		tstate = begin_tup_output_tupdesc(dest, retdesc,
+										  &TTSOpsHeapTuple);
+
+		rettupdata.t_len = HeapTupleHeaderGetDatumLength(td);
+		ItemPointerSetInvalid(&(rettupdata.t_self));
+		rettupdata.t_tableOid = InvalidOid;
+		rettupdata.t_data = td;
+
+		slot = ExecStoreHeapTuple(&rettupdata, tstate->slot, false);
+		tstate->dest->receiveSlot(slot, tstate->dest);
+
+		end_tup_output(tstate);
+
+		ReleaseTupleDesc(retdesc);
+	}
+	else
+		elog(ERROR, "unexpected result type for procedure: %u",
+			 fexpr->funcresulttype);
+
+	FreeExecutorState(estate);
+}
+
+/*
+ * Construct the tuple descriptor for a CALL statement return
+ */
+TupleDesc
+CallStmtResultDesc(CallStmt *stmt)
+{
+	FuncExpr   *fexpr;
+	HeapTuple	tuple;
+	TupleDesc	tupdesc;
+
+	fexpr = stmt->funcexpr;
+
+	tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(fexpr->funcid));
+	if (!HeapTupleIsValid(tuple))
+		elog(ERROR, "cache lookup failed for procedure %u", fexpr->funcid);
+
+	tupdesc = build_function_result_tupdesc_t(tuple);
+
+	ReleaseSysCache(tuple);
+
+	return tupdesc;
+}