/src/postgres/src/backend/commands/functioncmds.c

Source
/*-------------------------------------------------------------------------
 *
 * functioncmds.c
 *
 *    Routines for CREATE and DROP FUNCTION commands and CREATE and DROP
 *    CAST commands.
 *
 * Portions Copyright (c) 1996-2026, 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 "FooCreate" routines (in src/backend/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/htup_details.h"
#include "access/table.h"
#include "access/xact.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/defrem.h"
#include "commands/extension.h"
#include "commands/proclang.h"
#include "executor/executor.h"
#include "executor/functions.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.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/guc.h"
#include "utils/lsyscache.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_p.
 *
 * 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;
  bool    attempt_shell_creation;

  /*
   * If this looks like it could be an input function, and the type doesn't
   * exist, we'll create it as a shell type.
   *
   * If the type name contains any modifiers like %TYPE, type[] array
   * syntax, or typmod decoration, it's not an input function, or at least
   * not one for which we'd want to automatically create a shell type.
   *
   * 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.
   */
  attempt_shell_creation =
    !returnType->pct_type && returnType->arrayBounds == NULL &&
    returnType->typmods == NIL &&
    (languageOid == INTERNALlanguageId || languageOid == ClanguageId);

  typtup = LookupTypeName(NULL, returnType, NULL, false);
  if (typtup)
  {
    /*
     * Found an existing type with the given name.  Check if it's a shell
     * type.
     */
    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 if (!attempt_shell_creation)
  {
    /* Type not found and we don't want to create a shell type */
    ereport(ERROR,
        (errcode(ERRCODE_UNDEFINED_OBJECT),
         errmsg("type \"%s\" does not exist",
            TypeNameToString(returnType))));
  }
  else
  {
    /* Make a shell type */
    Oid     namespaceId;
    char     *typname;
    ObjectAddress address;

    ereport(NOTICE,
        (errcode(ERRCODE_UNDEFINED_OBJECT),
         errmsg("type \"%s\" is not yet defined",
            TypeNameToString(returnType)),
         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));
    /* Ensure the new shell type is visible to ProcedureCreate */
    CommandCounterIncrement();
  }

  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 = palloc_array(Oid, parameterCount);
  allTypes = palloc_array(Datum, parameterCount);
  paramModes = palloc_array(Datum, parameterCount);
  paramNames = palloc0_array(Datum, parameterCount);
  *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(pstate, 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)),
               parser_errposition(pstate, t->location)));
        /* 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)),
               parser_errposition(pstate, t->location)));
        else
          ereport(NOTICE,
              (errcode(ERRCODE_WRONG_OBJECT_TYPE),
               errmsg("argument type %s is only a shell",
                  TypeNameToString(t)),
               parser_errposition(pstate, t->location)));
      }
      toid = typeTypeId(typtup);
      ReleaseSysCache(typtup);
    }
    else
    {
      ereport(ERROR,
          (errcode(ERRCODE_UNDEFINED_OBJECT),
           errmsg("type %s does not exist",
              TypeNameToString(t)),
           parser_errposition(pstate, t->location)));
      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"),
             parser_errposition(pstate, fp->location)));
      else if (objtype == OBJECT_PROCEDURE)
        ereport(ERROR,
            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
             errmsg("procedures cannot accept set arguments"),
             parser_errposition(pstate, fp->location)));
      else
        ereport(ERROR,
            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
             errmsg("functions cannot accept set arguments"),
             parser_errposition(pstate, fp->location)));
    }

    /* 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"),
             parser_errposition(pstate, fp->location)));
      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"),
               parser_errposition(pstate, fp->location)));
        /* 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"),
                 parser_errposition(pstate, fp->location)));
          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),
               parser_errposition(pstate, fp->location)));
      }

      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"),
             parser_errposition(pstate, fp->location)));

      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"),
             parser_errposition(pstate, fp->location)));

      /*
       * 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"),
             parser_errposition(pstate, fp->location)));

      /*
       * 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"),
             parser_errposition(pstate, fp->location)));
    }

    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 = palloc0_object(SQLFunctionParseInfo);

    pinfo->fname = funcname;
    pinfo->nargs = list_length(parameterTypes);
    pinfo->argtypes = palloc_array(Oid, pinfo->nargs);
    pinfo->argnames = palloc_array(char *, pinfo->nargs);
    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;
  List     *trfoids_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);
      Oid     transformid;

      typeid = elt ? elt : typeid;
      transformid = get_transform_oid(typeid, languageOid, false);
      trftypes_list = lappend_oid(trftypes_list, typeid);
      trfoids_list = lappend_oid(trfoids_list, transformid);
    }
  }

  /*
   * 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_array(Datum, list_length(trftypes_list));
    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),
               trfoids_list,
               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))
    {
      if (changeDependencyFor(ProcedureRelationId, funcOid,
                  ProcedureRelationId, procForm->prosupport,
                  newsupport) != 1)
        elog(ERROR, "could not change support dependency for function %s",
           get_func_name(funcOid));
    }
    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, array, range and enum 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 such a type.  But we disallow it anyway, as
     * in practice such a cast is surely a mistake.  You can always work
     * around that by writing a cast function.
     *
     * NOTE: if we ever have a kind of container type that doesn't need to
     * be rejected for this reason, we'd likely need to recursively apply
     * all of these same checks to the contained type(s).
     */
    if (sourcetyptype == TYPTYPE_COMPOSITE ||
      targettyptype == TYPTYPE_COMPOSITE)
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
           errmsg("composite 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")));

    if (sourcetyptype == TYPTYPE_RANGE ||
      targettyptype == TYPTYPE_RANGE ||
      sourcetyptype == TYPTYPE_MULTIRANGE ||
      targettyptype == TYPTYPE_MULTIRANGE)
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
           errmsg("range 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")));

    /*
     * 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);

  /*
   * The result of build_function_result_tupdesc_t has the right column
   * names, but it just has the declared output argument types, which is the
   * wrong thing in polymorphic cases.  Get the correct types by examining
   * stmt->outargs.  We intentionally keep the atttypmod as -1 and the
   * attcollation as the type's default, since that's always the appropriate
   * thing for function outputs; there's no point in considering any
   * additional info available from outargs.  Note that tupdesc is null if
   * there are no outargs.
   */
  if (tupdesc)
  {
    Assert(tupdesc->natts == list_length(stmt->outargs));
    for (int i = 0; i < tupdesc->natts; i++)
    {
      Form_pg_attribute att = TupleDescAttr(tupdesc, i);
      Node     *outarg = (Node *) list_nth(stmt->outargs, i);

      TupleDescInitEntry(tupdesc,
                 i + 1,
                 NameStr(att->attname),
                 exprType(outarg),
                 -1,
                 0);
    }
    TupleDescFinalize(tupdesc);
  }

  return tupdesc;
}

Coverage Report

Created: 2026-09-28 06:55