Impressum pl_comp.c

/*-------------------------------------------------------------------------
 *
 * pl_comp.c  - Compiler part of the PL/pgSQL
 *     procedural language
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/pl/plpgsql/src/pl_comp.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include <ctype.h>

#include "access/htup_details.h"
#include "catalog/namespace.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "nodes/makefuncs.h"
#include "parser/parse_node.h"
#include "plpgsql.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/regproc.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

/* ----------
 * Our own local and global variables
 * ----------
 */
static int datums_alloc;
int   plpgsql_nDatums;
PLpgSQL_datum **plpgsql_Datums;
static int datums_last;

char    *plpgsql_error_funcname;
bool  plpgsql_DumpExecTree = false;
bool  plpgsql_check_syntax = false;

PLpgSQL_function *plpgsql_curr_compile;

/* A context appropriate for short-term allocs during compilation */
MemoryContext plpgsql_compile_tmp_cxt;

/* ----------
 * Lookup table for EXCEPTION condition names
 * ----------
 */
typedef struct
{
 const char *label;
 int   sqlerrstate;
} ExceptionLabelMap;

static const ExceptionLabelMap exception_label_map[] = {
#include "plerrcodes.h"
 {NULL, 0}
};


/* ----------
 * static prototypes
 * ----------
 */
static void plpgsql_compile_callback(FunctionCallInfo fcinfo,
          HeapTuple procTup,
          const CachedFunctionHashKey *hashkey,
          CachedFunction *cfunc,
          bool forValidator);
static void plpgsql_compile_error_callback(void *arg);
static void add_parameter_name(PLpgSQL_nsitem_type itemtype, int itemno, const char *name);
static void add_dummy_return(PLpgSQL_function *function);
static Node *plpgsql_pre_column_ref(ParseState *pstate, ColumnRef *cref);
static Node *plpgsql_post_column_ref(ParseState *pstate, ColumnRef *cref, Node *var);
static Node *plpgsql_param_ref(ParseState *pstate, ParamRef *pref);
static Node *resolve_column_ref(ParseState *pstate, PLpgSQL_expr *expr,
        ColumnRef *cref, bool error_if_no_field);
static Node *make_datum_param(PLpgSQL_expr *expr, int dno, int location);
static PLpgSQL_row *build_row_from_vars(PLpgSQL_variable **vars, int numvars);
static PLpgSQL_type *build_datatype(HeapTuple typeTup, int32 typmod,
         Oid collation, TypeName *origtypname);
static void plpgsql_start_datums(void);
static void plpgsql_finish_datums(PLpgSQL_function *function);

/* ----------
 * plpgsql_compile  Make an execution tree for a PL/pgSQL function.
 *
 * If forValidator is true, we're only compiling for validation purposes,
 * and so some checks are skipped.
 *
 * Note: it's important for this to fall through quickly if the function
 * has already been compiled.
 * ----------
 */
PLpgSQL_function *
plpgsql_compile(FunctionCallInfo fcinfo, bool forValidator)
{
 PLpgSQL_function *function;

 /*
  * funccache.c manages re-use of existing PLpgSQL_function caches.
  *
  * In PL/pgSQL we use fn_extra directly as the pointer to the long-lived
  * function cache entry; we have no need for any query-lifespan cache.
  * Also, we don't need to make the cache key depend on composite result
  * type (at least for now).
 */
 function = (PLpgSQL_function *)
  cached_function_compile(fcinfo,
        fcinfo->flinfo->fn_extra,
        plpgsql_compile_callback,
        plpgsql_delete_callback,
        sizeof(PLpgSQL_function),
        false,
        forValidator);

 /*
  * Save pointer in FmgrInfo to avoid search on subsequent calls
 */
 fcinfo->flinfo->fn_extra = function;

 /*
  * Finally return the compiled function
 */
 return function;
}

struct compile_error_callback_arg
{
 const char *proc_source;
 yyscan_t yyscanner;
};

/*
 * This is the slow part of plpgsql_compile().
 *
 * The passed-in "cfunc" struct is expected to be zeroes, except
 * for the CachedFunction fields, which we don't touch here.
 *
 * While compiling a function, the CurrentMemoryContext is the
 * per-function memory context of the function we are compiling. That
 * means a palloc() will allocate storage with the same lifetime as
 * the function itself.
 *
 * Because palloc()'d storage will not be immediately freed, temporary
 * allocations should either be performed in a short-lived memory
 * context or explicitly pfree'd. Since not all backend functions are
 * careful about pfree'ing their allocations, it is also wise to
 * switch into a short-term context before calling into the
 * backend. An appropriate context for performing short-term
 * allocations is the plpgsql_compile_tmp_cxt.
 *
 * NB: this code is not re-entrant.  We assume that nothing we do here could
 * result in the invocation of another plpgsql function.
 */
static void
plpgsql_compile_callback(FunctionCallInfo fcinfo,
       HeapTuple procTup,
       const CachedFunctionHashKey *hashkey,
       CachedFunction *cfunc,
       bool forValidator)
{
 PLpgSQL_function *function = (PLpgSQL_function *) cfunc;
 Form_pg_proc procStruct = (Form_pg_proc) GETSTRUCT(procTup);
 bool  is_dml_trigger = CALLED_AS_TRIGGER(fcinfo);
 bool  is_event_trigger = CALLED_AS_EVENT_TRIGGER(fcinfo);
 yyscan_t scanner;
 Datum  prosrcdatum;
 char    *proc_source;
 HeapTuple typeTup;
 Form_pg_type typeStruct;
 PLpgSQL_variable *var;
 PLpgSQL_rec *rec;
 int   i;
 struct compile_error_callback_arg cbarg;
 ErrorContextCallback plerrcontext;
 int   parse_rc;
 Oid   rettypeid;
 int   numargs;
 int   num_in_args = 0;
 int   num_out_args = 0;
 Oid     *argtypes;
 char   **argnames;
 char    *argmodes;
 int     *in_arg_varnos = NULL;
 PLpgSQL_variable **out_arg_variables;
 MemoryContext func_cxt;

 /*
  * Setup the scanner input and error info.
 */
 prosrcdatum = SysCacheGetAttrNotNull(PROCOID, procTup, Anum_pg_proc_prosrc);
 proc_source = TextDatumGetCString(prosrcdatum);
 scanner = plpgsql_scanner_init(proc_source);

 plpgsql_error_funcname = pstrdup(NameStr(procStruct->proname));

 /*
  * Setup error traceback support for ereport()
 */
 cbarg.proc_source = forValidator ? proc_source : NULL;
 cbarg.yyscanner = scanner;
 plerrcontext.callback = plpgsql_compile_error_callback;
 plerrcontext.arg = &cbarg;
 plerrcontext.previous = error_context_stack;
 error_context_stack = &plerrcontext;

 /*
  * Do extra syntax checks when validating the function definition. We skip
  * this when actually compiling functions for execution, for performance
  * reasons.
 */
 plpgsql_check_syntax = forValidator;
 plpgsql_curr_compile = function;

 /*
  * All the permanent output of compilation (e.g. parse tree) is kept in a
  * per-function memory context, so it can be reclaimed easily.
  *
  * While the func_cxt needs to be long-lived, we initially make it a child
  * of the assumed-short-lived caller's context, and reparent it under
  * CacheMemoryContext only upon success.  This arrangement avoids memory
  * leakage during compilation of a faulty function.
 */
 func_cxt = AllocSetContextCreate(CurrentMemoryContext,
          "PL/pgSQL function",
          ALLOCSET_DEFAULT_SIZES);
 plpgsql_compile_tmp_cxt = MemoryContextSwitchTo(func_cxt);

 function->fn_signature = format_procedure(fcinfo->flinfo->fn_oid);
 MemoryContextSetIdentifier(func_cxt, function->fn_signature);
 function->fn_oid = fcinfo->flinfo->fn_oid;
 function->fn_input_collation = fcinfo->fncollation;
 function->fn_cxt = func_cxt;
 function->out_param_varno = -1; /* set up for no OUT param */
 function->resolve_option = plpgsql_variable_conflict;
 function->print_strict_params = plpgsql_print_strict_params;
 /* only promote extra warnings and errors at CREATE FUNCTION time */
 function->extra_warnings = forValidator ? plpgsql_extra_warnings : 0;
 function->extra_errors = forValidator ? plpgsql_extra_errors : 0;

 if (is_dml_trigger)
  function->fn_is_trigger = PLPGSQL_DML_TRIGGER;
 else if (is_event_trigger)
  function->fn_is_trigger = PLPGSQL_EVENT_TRIGGER;
 else
  function->fn_is_trigger = PLPGSQL_NOT_TRIGGER;

 function->fn_prokind = procStruct->prokind;

 function->nstatements = 0;
 function->requires_procedure_resowner = false;
 function->has_exception_block = false;

 /*
  * Initialize the compiler, particularly the namespace stack.  The
  * outermost namespace contains function parameters and other special
  * variables (such as FOUND), and is named after the function itself.
 */
 plpgsql_ns_init();
 plpgsql_ns_push(NameStr(procStruct->proname), PLPGSQL_LABEL_BLOCK);
 plpgsql_DumpExecTree = false;
 plpgsql_start_datums();

 switch (function->fn_is_trigger)
 {
  case PLPGSQL_NOT_TRIGGER:

   /*
    * Fetch info about the procedure's parameters. Allocations aren't
    * needed permanently, so make them in tmp cxt.
    *
    * We also need to resolve any polymorphic input or output
    * argument types.  In validation mode we won't be able to, so we
    * arbitrarily assume we are dealing with integers.
 */
   MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);

   numargs = get_func_arg_info(procTup,
          &argtypes, &argnames, &argmodes);

   cfunc_resolve_polymorphic_argtypes(numargs, argtypes, argmodes,
              fcinfo->flinfo->fn_expr,
              forValidator,
              plpgsql_error_funcname);

   in_arg_varnos = (int *) palloc(numargs * sizeof(int));
   out_arg_variables = (PLpgSQL_variable **) palloc(numargs * sizeof(PLpgSQL_variable *));

   MemoryContextSwitchTo(func_cxt);

   /*
    * Create the variables for the procedure's parameters.
 */
   for (i = 0; i < numargs; i++)
   {
    char  buf[32];
    Oid   argtypeid = argtypes[i];
    char  argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
    PLpgSQL_type *argdtype;
    PLpgSQL_variable *argvariable;
    PLpgSQL_nsitem_type argitemtype;

    /* Create $n name for variable */
    snprintf(buf, sizeof(buf), "$%d", i + 1);

    /* Create datatype info */
    argdtype = plpgsql_build_datatype(argtypeid,
              -1,
              function->fn_input_collation,
              NULL);

    /* Disallow pseudotype argument */
    /* (note we already replaced polymorphic types) */
    /* (build_variable would do this, but wrong message) */
    if (argdtype->ttype == PLPGSQL_TTYPE_PSEUDO)
     ereport(ERROR,
       (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        errmsg("PL/pgSQL functions cannot accept type %s",
         format_type_be(argtypeid))));

    /*
     * Build variable and add to datum list.  If there's a name
     * for the argument, use that as refname, else use $n name.
 */
    argvariable = plpgsql_build_variable((argnames &&
               argnames[i][0] != '\0') ?
              argnames[i] : buf,
              0, argdtype, false);

    if (argvariable->dtype == PLPGSQL_DTYPE_VAR)
    {
     argitemtype = PLPGSQL_NSTYPE_VAR;
    }
    else
    {
     Assert(argvariable->dtype == PLPGSQL_DTYPE_REC);
     argitemtype = PLPGSQL_NSTYPE_REC;
    }

    /* Remember arguments in appropriate arrays */
    if (argmode == PROARGMODE_IN ||
     argmode == PROARGMODE_INOUT ||
     argmode == PROARGMODE_VARIADIC)
     in_arg_varnos[num_in_args++] = argvariable->dno;
    if (argmode == PROARGMODE_OUT ||
     argmode == PROARGMODE_INOUT ||
     argmode == PROARGMODE_TABLE)
     out_arg_variables[num_out_args++] = argvariable;

    /* Add to namespace under the $n name */
    add_parameter_name(argitemtype, argvariable->dno, buf);

    /* If there's a name for the argument, make an alias */
    if (argnames && argnames[i][0] != '\0')
     add_parameter_name(argitemtype, argvariable->dno,
            argnames[i]);
   }

   /*
    * If there's just one OUT parameter, out_param_varno points
    * directly to it.  If there's more than one, build a row that
    * holds all of them.  Procedures return a row even for one OUT
    * parameter.
 */
   if (num_out_args > 1 ||
    (num_out_args == 1 && function->fn_prokind == PROKIND_PROCEDURE))
   {
    PLpgSQL_row *row = build_row_from_vars(out_arg_variables,
                num_out_args);

    plpgsql_adddatum((PLpgSQL_datum *) row);
    function->out_param_varno = row->dno;
   }
   else if (num_out_args == 1)
    function->out_param_varno = out_arg_variables[0]->dno;

   /*
    * Check for a polymorphic returntype. If found, use the actual
    * returntype type from the caller's FuncExpr node, if we have
    * one.  (In validation mode we arbitrarily assume we are dealing
    * with integers.)
    *
    * Note: errcode is FEATURE_NOT_SUPPORTED because it should always
    * work; if it doesn't we're in some context that fails to make
    * the info available.
 */
   rettypeid = procStruct->prorettype;
   if (IsPolymorphicType(rettypeid))
   {
    if (forValidator)
    {
     if (rettypeid == ANYARRAYOID ||
      rettypeid == ANYCOMPATIBLEARRAYOID)
      rettypeid = INT4ARRAYOID;
     else if (rettypeid == ANYRANGEOID ||
        rettypeid == ANYCOMPATIBLERANGEOID)
      rettypeid = INT4RANGEOID;
     else if (rettypeid == ANYMULTIRANGEOID)
      rettypeid = INT4MULTIRANGEOID;
     else  /* ANYELEMENT or ANYNONARRAY or ANYCOMPATIBLE */
      rettypeid = INT4OID;
     /* XXX what could we use for ANYENUM? */
    }
    else
    {
     rettypeid = get_fn_expr_rettype(fcinfo->flinfo);
     if (!OidIsValid(rettypeid))
      ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         errmsg("could not determine actual return type "
          "for polymorphic function \"%s\"",
          plpgsql_error_funcname)));
    }
   }

   /*
    * Normal function has a defined returntype
 */
   function->fn_rettype = rettypeid;
   function->fn_retset = procStruct->proretset;

   /*
    * Lookup the function's return type
 */
   typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(rettypeid));
   if (!HeapTupleIsValid(typeTup))
    elog(ERROR, "cache lookup failed for type %u", rettypeid);
   typeStruct = (Form_pg_type) GETSTRUCT(typeTup);

   /* Disallow pseudotype result, except VOID or RECORD */
   /* (note we already replaced polymorphic types) */
   if (typeStruct->typtype == TYPTYPE_PSEUDO)
   {
    if (rettypeid == VOIDOID ||
     rettypeid == RECORDOID)
      /* okay */ ;
    else if (rettypeid == TRIGGEROID || rettypeid == EVENT_TRIGGEROID)
     ereport(ERROR,
       (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        errmsg("trigger functions can only be called as triggers")));
    else
     ereport(ERROR,
       (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        errmsg("PL/pgSQL functions cannot return type %s",
         format_type_be(rettypeid))));
   }

   function->fn_retistuple = type_is_rowtype(rettypeid);
   function->fn_retisdomain = (typeStruct->typtype == TYPTYPE_DOMAIN);
   function->fn_retbyval = typeStruct->typbyval;
   function->fn_rettyplen = typeStruct->typlen;

   /*
    * install $0 reference, but only for polymorphic return types,
    * and not when the return is specified through an output
    * parameter.
 */
   if (IsPolymorphicType(procStruct->prorettype) &&
    num_out_args == 0)
   {
    (void) plpgsql_build_variable("$0", 0,
             build_datatype(typeTup,
                -1,
                function->fn_input_collation,
                NULL),
             true);
   }

   ReleaseSysCache(typeTup);
   break;

  case PLPGSQL_DML_TRIGGER:
   /* Trigger procedure's return type is unknown yet */
   function->fn_rettype = InvalidOid;
   function->fn_retbyval = false;
   function->fn_retistuple = true;
   function->fn_retisdomain = false;
   function->fn_retset = false;

   /* shouldn't be any declared arguments */
   if (procStruct->pronargs != 0)
    ereport(ERROR,
      (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
       errmsg("trigger functions cannot have declared arguments"),
       errhint("The arguments of the trigger can be accessed through TG_NARGS and TG_ARGV instead.")));

   /* Add the record for referencing NEW ROW */
   rec = plpgsql_build_record("new", 0, NULL, RECORDOID, true);
   function->new_varno = rec->dno;

   /* Add the record for referencing OLD ROW */
   rec = plpgsql_build_record("old", 0, NULL, RECORDOID, true);
   function->old_varno = rec->dno;

   /* Add the variable tg_name */
   var = plpgsql_build_variable("tg_name", 0,
           plpgsql_build_datatype(NAMEOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_NAME;

   /* Add the variable tg_when */
   var = plpgsql_build_variable("tg_when", 0,
           plpgsql_build_datatype(TEXTOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_WHEN;

   /* Add the variable tg_level */
   var = plpgsql_build_variable("tg_level", 0,
           plpgsql_build_datatype(TEXTOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_LEVEL;

   /* Add the variable tg_op */
   var = plpgsql_build_variable("tg_op", 0,
           plpgsql_build_datatype(TEXTOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_OP;

   /* Add the variable tg_relid */
   var = plpgsql_build_variable("tg_relid", 0,
           plpgsql_build_datatype(OIDOID,
                -1,
                InvalidOid,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_RELID;

   /* Add the variable tg_relname */
   var = plpgsql_build_variable("tg_relname", 0,
           plpgsql_build_datatype(NAMEOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TABLE_NAME;

   /* tg_table_name is now preferred to tg_relname */
   var = plpgsql_build_variable("tg_table_name", 0,
           plpgsql_build_datatype(NAMEOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TABLE_NAME;

   /* add the variable tg_table_schema */
   var = plpgsql_build_variable("tg_table_schema", 0,
           plpgsql_build_datatype(NAMEOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TABLE_SCHEMA;

   /* Add the variable tg_nargs */
   var = plpgsql_build_variable("tg_nargs", 0,
           plpgsql_build_datatype(INT4OID,
                -1,
                InvalidOid,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_NARGS;

   /* Add the variable tg_argv */
   var = plpgsql_build_variable("tg_argv", 0,
           plpgsql_build_datatype(TEXTARRAYOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_ARGV;

   break;

  case PLPGSQL_EVENT_TRIGGER:
   function->fn_rettype = VOIDOID;
   function->fn_retbyval = false;
   function->fn_retistuple = true;
   function->fn_retisdomain = false;
   function->fn_retset = false;

   /* shouldn't be any declared arguments */
   if (procStruct->pronargs != 0)
    ereport(ERROR,
      (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
       errmsg("event trigger functions cannot have declared arguments")));

   /* Add the variable tg_event */
   var = plpgsql_build_variable("tg_event", 0,
           plpgsql_build_datatype(TEXTOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_EVENT;

   /* Add the variable tg_tag */
   var = plpgsql_build_variable("tg_tag", 0,
           plpgsql_build_datatype(TEXTOID,
                -1,
                function->fn_input_collation,
                NULL),
           true);
   Assert(var->dtype == PLPGSQL_DTYPE_VAR);
   var->dtype = PLPGSQL_DTYPE_PROMISE;
   ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TAG;

   break;

  default:
   elog(ERROR, "unrecognized function typecode: %d",
     (int) function->fn_is_trigger);
   break;
 }

 /* Remember if function is STABLE/IMMUTABLE */
 function->fn_readonly = (procStruct->provolatile != PROVOLATILE_VOLATILE);

 /*
  * Create the magic FOUND variable.
 */
 var = plpgsql_build_variable("found", 0,
         plpgsql_build_datatype(BOOLOID,
              -1,
              InvalidOid,
              NULL),
         true);
 function->found_varno = var->dno;

 /*
  * Now parse the function's text
 */
 parse_rc = plpgsql_yyparse(&function->action, scanner);
 if (parse_rc != 0)
  elog(ERROR, "plpgsql parser returned %d", parse_rc);

 plpgsql_scanner_finish(scanner);
 pfree(proc_source);

 /*
  * If it has OUT parameters or returns VOID or returns a set, we allow
  * control to fall off the end without an explicit RETURN statement. The
  * easiest way to implement this is to add a RETURN statement to the end
  * of the statement list during parsing.
 */
 if (num_out_args > 0 || function->fn_rettype == VOIDOID ||
  function->fn_retset)
  add_dummy_return(function);

 /*
  * Complete the function's info
 */
 function->fn_nargs = procStruct->pronargs;
 for (i = 0; i < function->fn_nargs; i++)
  function->fn_argvarnos[i] = in_arg_varnos[i];

 plpgsql_finish_datums(function);

 if (function->has_exception_block)
  plpgsql_mark_local_assignment_targets(function);

 /* Debug dump for completed functions */
 if (plpgsql_DumpExecTree)
  plpgsql_dumptree(function);

 /*
  * All is well, so make the func_cxt long-lived
 */
 MemoryContextSetParent(func_cxt, CacheMemoryContext);

 /*
  * Pop the error context stack
 */
 error_context_stack = plerrcontext.previous;
 plpgsql_error_funcname = NULL;

 plpgsql_check_syntax = false;

 MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
 plpgsql_compile_tmp_cxt = NULL;
}

/* ----------
 * plpgsql_compile_inline Make an execution tree for an anonymous code block.
 *
 * Note: this is generally parallel to plpgsql_compile_callback(); is it worth
 * trying to merge the two?
 *
 * Note: we assume the block will be thrown away so there is no need to build
 * persistent data structures.
 * ----------
 */
PLpgSQL_function *
plpgsql_compile_inline(char *proc_source)
{
 yyscan_t scanner;
 char    *func_name = "inline_code_block";
 PLpgSQL_function *function;
 struct compile_error_callback_arg cbarg;
 ErrorContextCallback plerrcontext;
 PLpgSQL_variable *var;
 int   parse_rc;
 MemoryContext func_cxt;

 /*
  * Setup the scanner input and error info.
 */
 scanner = plpgsql_scanner_init(proc_source);

 plpgsql_error_funcname = func_name;

 /*
  * Setup error traceback support for ereport()
 */
 cbarg.proc_source = proc_source;
 cbarg.yyscanner = scanner;
 plerrcontext.callback = plpgsql_compile_error_callback;
 plerrcontext.arg = &cbarg;
 plerrcontext.previous = error_context_stack;
 error_context_stack = &plerrcontext;

 /* Do extra syntax checking if check_function_bodies is on */
 plpgsql_check_syntax = check_function_bodies;

 /* Function struct does not live past current statement */
 function = (PLpgSQL_function *) palloc0(sizeof(PLpgSQL_function));

 plpgsql_curr_compile = function;

 /*
  * All the rest of the compile-time storage (e.g. parse tree) is kept in
  * its own memory context, so it can be reclaimed easily.
 */
 func_cxt = AllocSetContextCreate(CurrentMemoryContext,
          "PL/pgSQL inline code context",
          ALLOCSET_DEFAULT_SIZES);
 plpgsql_compile_tmp_cxt = MemoryContextSwitchTo(func_cxt);

 function->fn_signature = pstrdup(func_name);
 function->fn_is_trigger = PLPGSQL_NOT_TRIGGER;
 function->fn_input_collation = InvalidOid;
 function->fn_cxt = func_cxt;
 function->out_param_varno = -1; /* set up for no OUT param */
 function->resolve_option = plpgsql_variable_conflict;
 function->print_strict_params = plpgsql_print_strict_params;

 /*
  * don't do extra validation for inline code as we don't want to add spam
  * at runtime
 */
 function->extra_warnings = 0;
 function->extra_errors = 0;

 function->nstatements = 0;
 function->requires_procedure_resowner = false;
 function->has_exception_block = false;

 plpgsql_ns_init();
 plpgsql_ns_push(func_name, PLPGSQL_LABEL_BLOCK);
 plpgsql_DumpExecTree = false;
 plpgsql_start_datums();

 /* Set up as though in a function returning VOID */
 function->fn_rettype = VOIDOID;
 function->fn_retset = false;
 function->fn_retistuple = false;
 function->fn_retisdomain = false;
 function->fn_prokind = PROKIND_FUNCTION;
 /* a bit of hardwired knowledge about type VOID here */
 function->fn_retbyval = true;
 function->fn_rettyplen = sizeof(int32);

 /*
  * Remember if function is STABLE/IMMUTABLE.  XXX would it be better to
  * set this true inside a read-only transaction?  Not clear.
 */
 function->fn_readonly = false;

 /*
  * Create the magic FOUND variable.
 */
 var = plpgsql_build_variable("found", 0,
         plpgsql_build_datatype(BOOLOID,
              -1,
              InvalidOid,
              NULL),
         true);
 function->found_varno = var->dno;

 /*
  * Now parse the function's text
 */
 parse_rc = plpgsql_yyparse(&function->action, scanner);
 if (parse_rc != 0)
  elog(ERROR, "plpgsql parser returned %d", parse_rc);

 plpgsql_scanner_finish(scanner);

 /*
  * If it returns VOID (always true at the moment), we allow control to
  * fall off the end without an explicit RETURN statement.
 */
 if (function->fn_rettype == VOIDOID)
  add_dummy_return(function);

 /*
  * Complete the function's info
 */
 function->fn_nargs = 0;

 plpgsql_finish_datums(function);

 if (function->has_exception_block)
  plpgsql_mark_local_assignment_targets(function);

 /* Debug dump for completed functions */
 if (plpgsql_DumpExecTree)
  plpgsql_dumptree(function);

 /*
  * Pop the error context stack
 */
 error_context_stack = plerrcontext.previous;
 plpgsql_error_funcname = NULL;

 plpgsql_check_syntax = false;

 MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
 plpgsql_compile_tmp_cxt = NULL;
 return function;
}


/*
 * error context callback to let us supply a call-stack traceback.
 * If we are validating or executing an anonymous code block, the function
 * source text is passed as an argument.
 */
static void
plpgsql_compile_error_callback(void *arg)
{
 struct compile_error_callback_arg *cbarg = (struct compile_error_callback_arg *) arg;
 yyscan_t yyscanner = cbarg->yyscanner;

 if (cbarg->proc_source)
 {
  /*
   * Try to convert syntax error position to reference text of original
   * CREATE FUNCTION or DO command.
 */
  if (function_parse_error_transpose(cbarg->proc_source))
   return;

  /*
   * Done if a syntax error position was reported; otherwise we have to
   * fall back to a "near line N" report.
 */
 }

 if (plpgsql_error_funcname)
  errcontext("compilation of PL/pgSQL function \"%s\" near line %d",
       plpgsql_error_funcname, plpgsql_latest_lineno(yyscanner));
}


/*
 * Add a name for a function parameter to the function's namespace
 */
static void
add_parameter_name(PLpgSQL_nsitem_type itemtype, int itemno, const char *name)
{
 /*
  * Before adding the name, check for duplicates.  We need this even though
  * functioncmds.c has a similar check, because that code explicitly
  * doesn't complain about conflicting IN and OUT parameter names.  In
  * plpgsql, such names are in the same namespace, so there is no way to
  * disambiguate.
 */
 if (plpgsql_ns_lookup(plpgsql_ns_top(), true,
        name, NULL, NULL,
        NULL) != NULL)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("parameter name \"%s\" used more than once",
      name)));

 /* OK, add the name */
 plpgsql_ns_additem(itemtype, itemno, name);
}

/*
 * Add a dummy RETURN statement to the given function's body
 */
static void
add_dummy_return(PLpgSQL_function *function)
{
 /*
  * If the outer block has an EXCEPTION clause, we need to make a new outer
  * block, since the added RETURN shouldn't act like it is inside the
  * EXCEPTION clause.  Likewise, if it has a label, wrap it in a new outer
  * block so that EXIT doesn't skip the RETURN.
 */
 if (function->action->exceptions != NULL ||
  function->action->label != NULL)
 {
  PLpgSQL_stmt_block *new;

  new = palloc0(sizeof(PLpgSQL_stmt_block));
  new->cmd_type = PLPGSQL_STMT_BLOCK;
  new->stmtid = ++function->nstatements;
  new->body = list_make1(function->action);

  function->action = new;
 }
 if (function->action->body == NIL ||
  ((PLpgSQL_stmt *) llast(function->action->body))->cmd_type != PLPGSQL_STMT_RETURN)
 {
  PLpgSQL_stmt_return *new;

  new = palloc0(sizeof(PLpgSQL_stmt_return));
  new->cmd_type = PLPGSQL_STMT_RETURN;
  new->stmtid = ++function->nstatements;
  new->expr = NULL;
  new->retvarno = function->out_param_varno;

  function->action->body = lappend(function->action->body, new);
 }
}


/*
 * plpgsql_parser_setup  set up parser hooks for dynamic parameters
 *
 * Note: this routine, and the hook functions it prepares for, are logically
 * part of plpgsql parsing.  But they actually run during function execution,
 * when we are ready to evaluate a SQL query or expression that has not
 * previously been parsed and planned.
 */
void
plpgsql_parser_setup(struct ParseState *pstate, PLpgSQL_expr *expr)
{
 pstate->p_pre_columnref_hook = plpgsql_pre_column_ref;
 pstate->p_post_columnref_hook = plpgsql_post_column_ref;
 pstate->p_paramref_hook = plpgsql_param_ref;
 /* no need to use p_coerce_param_hook */
 pstate->p_ref_hook_state = expr;
}

/*
 * plpgsql_pre_column_ref  parser callback before parsing a ColumnRef
 */
static Node *
plpgsql_pre_column_ref(ParseState *pstate, ColumnRef *cref)
{
 PLpgSQL_expr *expr = (PLpgSQL_expr *) pstate->p_ref_hook_state;

 if (expr->func->resolve_option == PLPGSQL_RESOLVE_VARIABLE)
  return resolve_column_ref(pstate, expr, cref, false);
 else
  return NULL;
}

/*
 * plpgsql_post_column_ref  parser callback after parsing a ColumnRef
 */
static Node *
plpgsql_post_column_ref(ParseState *pstate, ColumnRef *cref, Node *var)
{
 PLpgSQL_expr *expr = (PLpgSQL_expr *) pstate->p_ref_hook_state;
 Node    *myvar;

 if (expr->func->resolve_option == PLPGSQL_RESOLVE_VARIABLE)
  return NULL;   /* we already found there's no match */

 if (expr->func->resolve_option == PLPGSQL_RESOLVE_COLUMN && var != NULL)
  return NULL;   /* there's a table column, prefer that */

 /*
  * If we find a record/row variable but can't match a field name, throw
  * error if there was no core resolution for the ColumnRef either.  In
  * that situation, the reference is inevitably going to fail, and
  * complaining about the record/row variable is likely to be more on-point
  * than the core parser's error message.  (It's too bad we don't have
  * access to transformColumnRef's internal crerr state here, as in case of
  * a conflict with a table name this could still be less than the most
  * helpful error message possible.)
 */
 myvar = resolve_column_ref(pstate, expr, cref, (var == NULL));

 if (myvar != NULL && var != NULL)
 {
  /*
   * We could leave it to the core parser to throw this error, but we
   * can add a more useful detail message than the core could.
 */
  ereport(ERROR,
    (errcode(ERRCODE_AMBIGUOUS_COLUMN),
     errmsg("column reference \"%s\" is ambiguous",
      NameListToString(cref->fields)),
     errdetail("It could refer to either a PL/pgSQL variable or a table column."),
     parser_errposition(pstate, cref->location)));
 }

 return myvar;
}

/*
 * plpgsql_param_ref  parser callback for ParamRefs ($n symbols)
 */
static Node *
plpgsql_param_ref(ParseState *pstate, ParamRef *pref)
{
 PLpgSQL_expr *expr = (PLpgSQL_expr *) pstate->p_ref_hook_state;
 char  pname[32];
 PLpgSQL_nsitem *nse;

 snprintf(pname, sizeof(pname), "$%d", pref->number);

 nse = plpgsql_ns_lookup(expr->ns, false,
       pname, NULL, NULL,
       NULL);

 if (nse == NULL)
  return NULL;   /* name not known to plpgsql */

 return make_datum_param(expr, nse->itemno, pref->location);
}

/*
 * resolve_column_ref  attempt to resolve a ColumnRef as a plpgsql var
 *
 * Returns the translated node structure, or NULL if name not found
 *
 * error_if_no_field tells whether to throw error or quietly return NULL if
 * we are able to match a record/row name but don't find a field name match.
 */
static Node *
resolve_column_ref(ParseState *pstate, PLpgSQL_expr *expr,
       ColumnRef *cref, bool error_if_no_field)
{
 PLpgSQL_execstate *estate;
 PLpgSQL_nsitem *nse;
 const char *name1;
 const char *name2 = NULL;
 const char *name3 = NULL;
 const char *colname = NULL;
 int   nnames;
 int   nnames_scalar = 0;
 int   nnames_wholerow = 0;
 int   nnames_field = 0;

 /*
  * We use the function's current estate to resolve parameter data types.
  * This is really pretty bogus because there is no provision for updating
  * plans when those types change ...
 */
 estate = expr->func->cur_estate;

 /*----------
  * The allowed syntaxes are:
  *
  * A  Scalar variable reference, or whole-row record reference.
  * A.B  Qualified scalar or whole-row reference, or field reference.
  * A.B.C Qualified record field reference.
  * A.*  Whole-row record reference.
  * A.B.* Qualified whole-row record reference.
  *----------
 */
 switch (list_length(cref->fields))
 {
  case 1:
   {
    Node    *field1 = (Node *) linitial(cref->fields);

    name1 = strVal(field1);
    nnames_scalar = 1;
    nnames_wholerow = 1;
    break;
   }
  case 2:
   {
    Node    *field1 = (Node *) linitial(cref->fields);
    Node    *field2 = (Node *) lsecond(cref->fields);

    name1 = strVal(field1);

    /* Whole-row reference? */
    if (IsA(field2, A_Star))
    {
     /* Set name2 to prevent matches to scalar variables */
     name2 = "*";
     nnames_wholerow = 1;
     break;
    }

    name2 = strVal(field2);
    colname = name2;
    nnames_scalar = 2;
    nnames_wholerow = 2;
    nnames_field = 1;
    break;
   }
  case 3:
   {
    Node    *field1 = (Node *) linitial(cref->fields);
    Node    *field2 = (Node *) lsecond(cref->fields);
    Node    *field3 = (Node *) lthird(cref->fields);

    name1 = strVal(field1);
    name2 = strVal(field2);

    /* Whole-row reference? */
    if (IsA(field3, A_Star))
    {
     /* Set name3 to prevent matches to scalar variables */
     name3 = "*";
     nnames_wholerow = 2;
     break;
    }

    name3 = strVal(field3);
    colname = name3;
    nnames_field = 2;
    break;
   }
  default:
   /* too many names, ignore */
   return NULL;
 }

 nse = plpgsql_ns_lookup(expr->ns, false,
       name1, name2, name3,
       &nnames);

 if (nse == NULL)
  return NULL;   /* name not known to plpgsql */

 switch (nse->itemtype)
 {
  case PLPGSQL_NSTYPE_VAR:
   if (nnames == nnames_scalar)
    return make_datum_param(expr, nse->itemno, cref->location);
   break;
  case PLPGSQL_NSTYPE_REC:
   if (nnames == nnames_wholerow)
    return make_datum_param(expr, nse->itemno, cref->location);
   if (nnames == nnames_field)
   {
    /* colname could be a field in this record */
    PLpgSQL_rec *rec = (PLpgSQL_rec *) estate->datums[nse->itemno];
    int   i;

    /* search for a datum referencing this field */
    i = rec->firstfield;
    while (i >= 0)
    {
     PLpgSQL_recfield *fld = (PLpgSQL_recfield *) estate->datums[i];

     Assert(fld->dtype == PLPGSQL_DTYPE_RECFIELD &&
         fld->recparentno == nse->itemno);
     if (strcmp(fld->fieldname, colname) == 0)
     {
      return make_datum_param(expr, i, cref->location);
     }
     i = fld->nextfield;
    }

    /*
     * We should not get here, because a RECFIELD datum should
     * have been built at parse time for every possible qualified
     * reference to fields of this record.  But if we do, handle
     * it like field-not-found: throw error or return NULL.
 */
    if (error_if_no_field)
     ereport(ERROR,
       (errcode(ERRCODE_UNDEFINED_COLUMN),
        errmsg("record \"%s\" has no field \"%s\"",
         (nnames_field == 1) ? name1 : name2,
         colname),
        parser_errposition(pstate, cref->location)));
   }
   break;
  default:
   elog(ERROR, "unrecognized plpgsql itemtype: %d", nse->itemtype);
 }

 /* Name format doesn't match the plpgsql variable type */
 return NULL;
}

/*
 * Helper for columnref parsing: build a Param referencing a plpgsql datum,
 * and make sure that that datum is listed in the expression's paramnos.
 */
static Node *
make_datum_param(PLpgSQL_expr *expr, int dno, int location)
{
 PLpgSQL_execstate *estate;
 PLpgSQL_datum *datum;
 Param    *param;
 MemoryContext oldcontext;

 /* see comment in resolve_column_ref */
 estate = expr->func->cur_estate;
 Assert(dno >= 0 && dno < estate->ndatums);
 datum = estate->datums[dno];

 /*
  * Bitmapset must be allocated in function's permanent memory context
 */
 oldcontext = MemoryContextSwitchTo(expr->func->fn_cxt);
 expr->paramnos = bms_add_member(expr->paramnos, dno);
 MemoryContextSwitchTo(oldcontext);

 param = makeNode(Param);
 param->paramkind = PARAM_EXTERN;
 param->paramid = dno + 1;
 plpgsql_exec_get_datum_type_info(estate,
          datum,
          ¶m->paramtype,
          ¶m->paramtypmod,
          ¶m->paramcollid);
 param->location = location;

 return (Node *) param;
}


/* ----------
 * plpgsql_parse_word  The scanner calls this to postparse
 *    any single word that is not a reserved keyword.
 *
 * word1 is the downcased/dequoted identifier; it must be palloc'd in the
 * function's long-term memory context.
 *
 * yytxt is the original token text; we need this to check for quoting,
 * so that later checks for unreserved keywords work properly.
 *
 * We attempt to recognize the token as a variable only if lookup is true
 * and the plpgsql_IdentifierLookup context permits it.
 *
 * If recognized as a variable, fill in *wdatum and return true;
 * if not recognized, fill in *word and return false.
 * (Note: those two pointers actually point to members of the same union,
 * but for notational reasons we pass them separately.)
 * ----------
 */
bool
plpgsql_parse_word(char *word1, const char *yytxt, bool lookup,
       PLwdatum *wdatum, PLword *word)
{
 PLpgSQL_nsitem *ns;

 /*
  * We should not lookup variables in DECLARE sections.  In SQL
  * expressions, there's no need to do so either --- lookup will happen
  * when the expression is compiled.
 */
 if (lookup && plpgsql_IdentifierLookup == IDENTIFIER_LOOKUP_NORMAL)
 {
  /*
   * Do a lookup in the current namespace stack
 */
  ns = plpgsql_ns_lookup(plpgsql_ns_top(), false,
          word1, NULL, NULL,
          NULL);

  if (ns != NULL)
  {
   switch (ns->itemtype)
   {
    case PLPGSQL_NSTYPE_VAR:
    case PLPGSQL_NSTYPE_REC:
     wdatum->datum = plpgsql_Datums[ns->itemno];
     wdatum->ident = word1;
     wdatum->quoted = (yytxt[0] == '"');
     wdatum->idents = NIL;
     return true;

    default:
     /* plpgsql_ns_lookup should never return anything else */
     elog(ERROR, "unrecognized plpgsql itemtype: %d",
       ns->itemtype);
   }
  }
 }

 /*
  * Nothing found - up to now it's a word without any special meaning for
  * us.
 */
 word->ident = word1;
 word->quoted = (yytxt[0] == '"');
 return false;
}


/* ----------
 * plpgsql_parse_dblword  Same lookup for two words
 *     separated by a dot.
 * ----------
 */
bool
plpgsql_parse_dblword(char *word1, char *word2,
       PLwdatum *wdatum, PLcword *cword)
{
 PLpgSQL_nsitem *ns;
 List    *idents;
 int   nnames;

 idents = list_make2(makeString(word1),
      makeString(word2));

 /*
  * We should do nothing in DECLARE sections.  In SQL expressions, we
  * really only need to make sure that RECFIELD datums are created when
  * needed.  In all the cases handled by this function, returning a T_DATUM
  * with a two-word idents string is the right thing.
 */
 if (plpgsql_IdentifierLookup != IDENTIFIER_LOOKUP_DECLARE)
 {
  /*
   * Do a lookup in the current namespace stack
 */
  ns = plpgsql_ns_lookup(plpgsql_ns_top(), false,
          word1, word2, NULL,
          &nnames);
  if (ns != NULL)
  {
   switch (ns->itemtype)
   {
    case PLPGSQL_NSTYPE_VAR:
     /* Block-qualified reference to scalar variable. */
     wdatum->datum = plpgsql_Datums[ns->itemno];
     wdatum->ident = NULL;
     wdatum->quoted = false; /* not used */
     wdatum->idents = idents;
     return true;

    case PLPGSQL_NSTYPE_REC:
     if (nnames == 1)
     {
      /*
       * First word is a record name, so second word could
       * be a field in this record.  We build a RECFIELD
       * datum whether it is or not --- any error will be
       * detected later.
 */
      PLpgSQL_rec *rec;
      PLpgSQL_recfield *new;

      rec = (PLpgSQL_rec *) (plpgsql_Datums[ns->itemno]);
      new = plpgsql_build_recfield(rec, word2);

      wdatum->datum = (PLpgSQL_datum *) new;
     }
     else
     {
      /* Block-qualified reference to record variable. */
      wdatum->datum = plpgsql_Datums[ns->itemno];
     }
     wdatum->ident = NULL;
     wdatum->quoted = false; /* not used */
     wdatum->idents = idents;
     return true;

    default:
     break;
   }
  }
 }

 /* Nothing found */
 cword->idents = idents;
 return false;
}


/* ----------
 * plpgsql_parse_tripword  Same lookup for three words
 *     separated by dots.
 * ----------
 */
bool
plpgsql_parse_tripword(char *word1, char *word2, char *word3,
        PLwdatum *wdatum, PLcword *cword)
{
 PLpgSQL_nsitem *ns;
 List    *idents;
 int   nnames;

 /*
  * We should do nothing in DECLARE sections.  In SQL expressions, we need
  * to make sure that RECFIELD datums are created when needed, and we need
  * to be careful about how many names are reported as belonging to the
  * T_DATUM: the third word could be a sub-field reference, which we don't
  * care about here.
 */
 if (plpgsql_IdentifierLookup != IDENTIFIER_LOOKUP_DECLARE)
 {
  /*
   * Do a lookup in the current namespace stack.  Must find a record
   * reference, else ignore.
 */
  ns = plpgsql_ns_lookup(plpgsql_ns_top(), false,
          word1, word2, word3,
          &nnames);
  if (ns != NULL)
  {
   switch (ns->itemtype)
   {
    case PLPGSQL_NSTYPE_REC:
     {
      PLpgSQL_rec *rec;
      PLpgSQL_recfield *new;

      rec = (PLpgSQL_rec *) (plpgsql_Datums[ns->itemno]);
      if (nnames == 1)
      {
       /*
        * First word is a record name, so second word
        * could be a field in this record (and the third,
        * a sub-field).  We build a RECFIELD datum
        * whether it is or not --- any error will be
        * detected later.
 */
       new = plpgsql_build_recfield(rec, word2);
       idents = list_make2(makeString(word1),
            makeString(word2));
      }
      else
      {
       /* Block-qualified reference to record variable. */
       new = plpgsql_build_recfield(rec, word3);
       idents = list_make3(makeString(word1),
            makeString(word2),
            makeString(word3));
      }
      wdatum->datum = (PLpgSQL_datum *) new;
      wdatum->ident = NULL;
      wdatum->quoted = false; /* not used */
      wdatum->idents = idents;
      return true;
     }

    default:
     break;
   }
  }
 }

 /* Nothing found */
 idents = list_make3(makeString(word1),
      makeString(word2),
      makeString(word3));
 cword->idents = idents;
 return false;
}


/* ----------
 * plpgsql_parse_wordtype The scanner found word%TYPE. word should be
 *    a pre-existing variable name.
 *
 * Returns datatype struct.  Throws error if no match found for word.
 * ----------
 */
PLpgSQL_type *
plpgsql_parse_wordtype(char *ident)
{
 PLpgSQL_nsitem *nse;

 /*
  * Do a lookup in the current namespace stack
 */
 nse = plpgsql_ns_lookup(plpgsql_ns_top(), false,
       ident, NULL, NULL,
       NULL);

 if (nse != NULL)
 {
  switch (nse->itemtype)
  {
   case PLPGSQL_NSTYPE_VAR:
    return ((PLpgSQL_var *) (plpgsql_Datums[nse->itemno]))->datatype;
   case PLPGSQL_NSTYPE_REC:
    return ((PLpgSQL_rec *) (plpgsql_Datums[nse->itemno]))->datatype;
   default:
    break;
  }
 }

 /* No match, complain */
 ereport(ERROR,
   (errcode(ERRCODE_UNDEFINED_OBJECT),
    errmsg("variable \"%s\" does not exist", ident)));
 return NULL;    /* keep compiler quiet */
}


/* ----------
 * plpgsql_parse_cwordtype  Same lookup for compositeword%TYPE
 *
 * Here, we allow either a block-qualified variable name, or a reference
 * to a column of some table.  (If we must throw error, we assume that the
 * latter case was intended.)
 * ----------
 */
PLpgSQL_type *
plpgsql_parse_cwordtype(List *idents)
{
 PLpgSQL_type *dtype = NULL;
 PLpgSQL_nsitem *nse;
 int   nnames;
 RangeVar   *relvar = NULL;
 const char *fldname = NULL;
 Oid   classOid;
 HeapTuple attrtup = NULL;
 HeapTuple typetup = NULL;
 Form_pg_attribute attrStruct;
 MemoryContext oldCxt;

 /* Avoid memory leaks in the long-term function context */
 oldCxt = MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);

 if (list_length(idents) == 2)
 {
  /*
   * Do a lookup in the current namespace stack
 */
  nse = plpgsql_ns_lookup(plpgsql_ns_top(), false,
        strVal(linitial(idents)),
        strVal(lsecond(idents)),
        NULL,
        &nnames);

  if (nse != NULL && nse->itemtype == PLPGSQL_NSTYPE_VAR)
  {
   /* Block-qualified reference to scalar variable. */
   dtype = ((PLpgSQL_var *) (plpgsql_Datums[nse->itemno]))->datatype;
   goto done;
  }
  else if (nse != NULL && nse->itemtype == PLPGSQL_NSTYPE_REC &&
     nnames == 2)
  {
   /* Block-qualified reference to record variable. */
   dtype = ((PLpgSQL_rec *) (plpgsql_Datums[nse->itemno]))->datatype;
   goto done;
  }

  /*
   * First word could also be a table name
 */
  relvar = makeRangeVar(NULL,
         strVal(linitial(idents)),
         -1);
  fldname = strVal(lsecond(idents));
 }
 else
 {
  /*
   * We could check for a block-qualified reference to a field of a
   * record variable, but %TYPE is documented as applying to variables,
   * not fields of variables.  Things would get rather ambiguous if we
   * allowed either interpretation.
 */
  List    *rvnames;

  Assert(list_length(idents) > 2);
  rvnames = list_delete_last(list_copy(idents));
  relvar = makeRangeVarFromNameList(rvnames);
  fldname = strVal(llast(idents));
 }

 /* Look up relation name.  Can't lock it - we might not have privileges. */
 classOid = RangeVarGetRelid(relvar, NoLock, false);

 /*
  * Fetch the named table field and its type
 */
 attrtup = SearchSysCacheAttName(classOid, fldname);
 if (!HeapTupleIsValid(attrtup))
  ereport(ERROR,
    (errcode(ERRCODE_UNDEFINED_COLUMN),
     errmsg("column \"%s\" of relation \"%s\" does not exist",
      fldname, relvar->relname)));
 attrStruct = (Form_pg_attribute) GETSTRUCT(attrtup);

 typetup = SearchSysCache1(TYPEOID,
         ObjectIdGetDatum(attrStruct->atttypid));
 if (!HeapTupleIsValid(typetup))
  elog(ERROR, "cache lookup failed for type %u", attrStruct->atttypid);

 /*
  * Found that - build a compiler type struct in the caller's cxt and
  * return it.  Note that we treat the type as being found-by-OID; no
  * attempt to re-look-up the type name will happen during invalidations.
 */
 MemoryContextSwitchTo(oldCxt);
 dtype = build_datatype(typetup,
         attrStruct->atttypmod,
         attrStruct->attcollation,
         NULL);
 MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);

done:
 if (HeapTupleIsValid(attrtup))
  ReleaseSysCache(attrtup);
 if (HeapTupleIsValid(typetup))
  ReleaseSysCache(typetup);

 MemoryContextSwitchTo(oldCxt);
 return dtype;
}

/* ----------
 * plpgsql_parse_wordrowtype  Scanner found word%ROWTYPE.
 *     So word must be a table name.
 * ----------
 */
PLpgSQL_type *
plpgsql_parse_wordrowtype(char *ident)
{
 Oid   classOid;
 Oid   typOid;

 /*
  * Look up the relation.  Note that because relation rowtypes have the
  * same names as their relations, this could be handled as a type lookup
  * equally well; we use the relation lookup code path only because the
  * errors thrown here have traditionally referred to relations not types.
  * But we'll make a TypeName in case we have to do re-look-up of the type.
 */
 classOid = RelnameGetRelid(ident);
 if (!OidIsValid(classOid))
  ereport(ERROR,
    (errcode(ERRCODE_UNDEFINED_TABLE),
     errmsg("relation \"%s\" does not exist", ident)));

 /* Some relkinds lack type OIDs */
 typOid = get_rel_type_id(classOid);
 if (!OidIsValid(typOid))
  ereport(ERROR,
    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
     errmsg("relation \"%s\" does not have a composite type",
      ident)));

 /* Build and return the row type struct */
 return plpgsql_build_datatype(typOid, -1, InvalidOid,
          makeTypeName(ident));
}

/* ----------
 * plpgsql_parse_cwordrowtype  Scanner found compositeword%ROWTYPE.
 *   So word must be a namespace qualified table name.
 * ----------
 */
PLpgSQL_type *
plpgsql_parse_cwordrowtype(List *idents)
{
 Oid   classOid;
 Oid   typOid;
 RangeVar   *relvar;
 MemoryContext oldCxt;

 /*
  * As above, this is a relation lookup but could be a type lookup if we
  * weren't being backwards-compatible about error wording.
 */

 /* Avoid memory leaks in long-term function context */
 oldCxt = MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);

 /* Look up relation name.  Can't lock it - we might not have privileges. */
 relvar = makeRangeVarFromNameList(idents);
 classOid = RangeVarGetRelid(relvar, NoLock, false);

 /* Some relkinds lack type OIDs */
 typOid = get_rel_type_id(classOid);
 if (!OidIsValid(typOid))
  ereport(ERROR,
    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
     errmsg("relation \"%s\" does not have a composite type",
      relvar->relname)));

 MemoryContextSwitchTo(oldCxt);

 /* Build and return the row type struct */
 return plpgsql_build_datatype(typOid, -1, InvalidOid,
          makeTypeNameFromNameList(idents));
}

/*
 * plpgsql_build_variable - build a datum-array entry of a given
 * datatype
 *
 * The returned struct may be a PLpgSQL_var or PLpgSQL_rec
 * depending on the given datatype, and is allocated via
 * palloc.  The struct is automatically added to the current datum
 * array, and optionally to the current namespace.
 */
PLpgSQL_variable *
plpgsql_build_variable(const char *refname, int lineno, PLpgSQL_type *dtype,
        bool add2namespace)
{
 PLpgSQL_variable *result;

 switch (dtype->ttype)
 {
  case PLPGSQL_TTYPE_SCALAR:
   {
    /* Ordinary scalar datatype */
    PLpgSQL_var *var;

    var = palloc0(sizeof(PLpgSQL_var));
    var->dtype = PLPGSQL_DTYPE_VAR;
    var->refname = pstrdup(refname);
    var->lineno = lineno;
    var->datatype = dtype;
    /* other fields are left as 0, might be changed by caller */

    /* preset to NULL */
    var->value = 0;
    var->isnull = true;
    var->freeval = false;

    plpgsql_adddatum((PLpgSQL_datum *) var);
    if (add2namespace)
     plpgsql_ns_additem(PLPGSQL_NSTYPE_VAR,
            var->dno,
            refname);
    result = (PLpgSQL_variable *) var;
    break;
   }
  case PLPGSQL_TTYPE_REC:
   {
    /* Composite type -- build a record variable */
    PLpgSQL_rec *rec;

    rec = plpgsql_build_record(refname, lineno,
             dtype, dtype->typoid,
             add2namespace);
    result = (PLpgSQL_variable *) rec;
    break;
   }
  case PLPGSQL_TTYPE_PSEUDO:
   ereport(ERROR,
     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
      errmsg("variable \"%s\" has pseudo-type %s",
       refname, format_type_be(dtype->typoid))));
   result = NULL;  /* keep compiler quiet */
   break;
  default:
   elog(ERROR, "unrecognized ttype: %d", dtype->ttype);
   result = NULL;  /* keep compiler quiet */
   break;
 }

 return result;
}

/*
 * Build empty named record variable, and optionally add it to namespace
 */
PLpgSQL_rec *
plpgsql_build_record(const char *refname, int lineno,
      PLpgSQL_type *dtype, Oid rectypeid,
      bool add2namespace)
{
 PLpgSQL_rec *rec;

 rec = palloc0(sizeof(PLpgSQL_rec));
 rec->dtype = PLPGSQL_DTYPE_REC;
 rec->refname = pstrdup(refname);
 rec->lineno = lineno;
 /* other fields are left as 0, might be changed by caller */
 rec->datatype = dtype;
 rec->rectypeid = rectypeid;
 rec->firstfield = -1;
 rec->erh = NULL;
 plpgsql_adddatum((PLpgSQL_datum *) rec);
 if (add2namespace)
  plpgsql_ns_additem(PLPGSQL_NSTYPE_REC, rec->dno, rec->refname);

 return rec;
}

/*
 * Build a row-variable data structure given the component variables.
 * Include a rowtupdesc, since we will need to materialize the row result.
 */
static PLpgSQL_row *
build_row_from_vars(PLpgSQL_variable **vars, int numvars)
{
 PLpgSQL_row *row;
 int   i;

 row = palloc0(sizeof(PLpgSQL_row));
 row->dtype = PLPGSQL_DTYPE_ROW;
 row->refname = "(unnamed row)";
 row->lineno = -1;
 row->rowtupdesc = CreateTemplateTupleDesc(numvars);
 row->nfields = numvars;
 row->fieldnames = palloc(numvars * sizeof(char *));
 row->varnos = palloc(numvars * sizeof(int));

 for (i = 0; i < numvars; i++)
 {
  PLpgSQL_variable *var = vars[i];
  Oid   typoid;
  int32  typmod;
  Oid   typcoll;

  /* Member vars of a row should never be const */
  Assert(!var->isconst);

  switch (var->dtype)
  {
   case PLPGSQL_DTYPE_VAR:
   case PLPGSQL_DTYPE_PROMISE:
    typoid = ((PLpgSQL_var *) var)->datatype->typoid;
    typmod = ((PLpgSQL_var *) var)->datatype->atttypmod;
    typcoll = ((PLpgSQL_var *) var)->datatype->collation;
    break;

   case PLPGSQL_DTYPE_REC:
    /* shouldn't need to revalidate rectypeid already... */
    typoid = ((PLpgSQL_rec *) var)->rectypeid;
    typmod = -1; /* don't know typmod, if it's used at all */
    typcoll = InvalidOid; /* composite types have no collation */
    break;

   default:
    elog(ERROR, "unrecognized dtype: %d", var->dtype);
    typoid = InvalidOid; /* keep compiler quiet */
    typmod = 0;
    typcoll = InvalidOid;
    break;
  }

  row->fieldnames[i] = var->refname;
  row->varnos[i] = var->dno;

  TupleDescInitEntry(row->rowtupdesc, i + 1,
         var->refname,
         typoid, typmod,
         0);
  TupleDescInitEntryCollation(row->rowtupdesc, i + 1, typcoll);
 }

 return row;
}

/*
 * Build a RECFIELD datum for the named field of the specified record variable
 *
 * If there's already such a datum, just return it; we don't need duplicates.
 */
PLpgSQL_recfield *
plpgsql_build_recfield(PLpgSQL_rec *rec, const char *fldname)
{
 PLpgSQL_recfield *recfield;
 int   i;

 /* search for an existing datum referencing this field */
 i = rec->firstfield;
 while (i >= 0)
 {
  PLpgSQL_recfield *fld = (PLpgSQL_recfield *) plpgsql_Datums[i];

  Assert(fld->dtype == PLPGSQL_DTYPE_RECFIELD &&
      fld->recparentno == rec->dno);
  if (strcmp(fld->fieldname, fldname) == 0)
   return fld;
  i = fld->nextfield;
 }

 /* nope, so make a new one */
 recfield = palloc0(sizeof(PLpgSQL_recfield));
 recfield->dtype = PLPGSQL_DTYPE_RECFIELD;
 recfield->fieldname = pstrdup(fldname);
 recfield->recparentno = rec->dno;
 recfield->rectupledescid = INVALID_TUPLEDESC_IDENTIFIER;

 plpgsql_adddatum((PLpgSQL_datum *) recfield);

 /* now we can link it into the parent's chain */
 recfield->nextfield = rec->firstfield;
 rec->firstfield = recfield->dno;

 return recfield;
}

/*
 * plpgsql_build_datatype
 *  Build PLpgSQL_type struct given type OID, typmod, collation,
 *  and type's parsed name.
 *
 * If collation is not InvalidOid then it overrides the type's default
 * collation.  But collation is ignored if the datatype is non-collatable.
 *
 * origtypname is the parsed form of what the user wrote as the type name.
 * It can be NULL if the type could not be a composite type, or if it was
 * identified by OID to begin with (e.g., it's a function argument type).
 */
PLpgSQL_type *
plpgsql_build_datatype(Oid typeOid, int32 typmod,
        Oid collation, TypeName *origtypname)
{
 HeapTuple typeTup;
 PLpgSQL_type *typ;

 typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typeOid));
 if (!HeapTupleIsValid(typeTup))
  elog(ERROR, "cache lookup failed for type %u", typeOid);

 typ = build_datatype(typeTup, typmod, collation, origtypname);

 ReleaseSysCache(typeTup);

 return typ;
}

/*
 * Utility subroutine to make a PLpgSQL_type struct given a pg_type entry
 * and additional details (see comments for plpgsql_build_datatype).
 */
static PLpgSQL_type *
build_datatype(HeapTuple typeTup, int32 typmod,
      Oid collation, TypeName *origtypname)
{
 Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
 PLpgSQL_type *typ;

 if (!typeStruct->typisdefined)
  ereport(ERROR,
    (errcode(ERRCODE_UNDEFINED_OBJECT),
     errmsg("type \"%s\" is only a shell",
      NameStr(typeStruct->typname))));

 typ = (PLpgSQL_type *) palloc(sizeof(PLpgSQL_type));

 typ->typname = pstrdup(NameStr(typeStruct->typname));
 typ->typoid = typeStruct->oid;
 switch (typeStruct->typtype)
 {
  case TYPTYPE_BASE:
  case TYPTYPE_ENUM:
  case TYPTYPE_RANGE:
  case TYPTYPE_MULTIRANGE:
   typ->ttype = PLPGSQL_TTYPE_SCALAR;
   break;
  case TYPTYPE_COMPOSITE:
   typ->ttype = PLPGSQL_TTYPE_REC;
   break;
  case TYPTYPE_DOMAIN:
   if (type_is_rowtype(typeStruct->typbasetype))
    typ->ttype = PLPGSQL_TTYPE_REC;
   else
    typ->ttype = PLPGSQL_TTYPE_SCALAR;
   break;
  case TYPTYPE_PSEUDO:
   if (typ->typoid == RECORDOID)
    typ->ttype = PLPGSQL_TTYPE_REC;
   else
    typ->ttype = PLPGSQL_TTYPE_PSEUDO;
   break;
  default:
   elog(ERROR, "unrecognized typtype: %d",
     (int) typeStruct->typtype);
   break;
 }
 typ->typlen = typeStruct->typlen;
 typ->typbyval = typeStruct->typbyval;
 typ->typtype = typeStruct->typtype;
 typ->collation = typeStruct->typcollation;
 if (OidIsValid(collation) && OidIsValid(typ->collation))
  typ->collation = collation;
 /* Detect if type is true array, or domain thereof */
 /* NB: this is only used to decide whether to apply expand_array */
 if (typeStruct->typtype == TYPTYPE_BASE)
 {
  /*
   * This test should include what get_element_type() checks.  We also
   * disallow non-toastable array types (i.e. oidvector and int2vector).
 */
  typ->typisarray = (IsTrueArrayType(typeStruct) &&
         typeStruct->typstorage != TYPSTORAGE_PLAIN);
 }
 else if (typeStruct->typtype == TYPTYPE_DOMAIN)
 {
  /* we can short-circuit looking up base types if it's not varlena */
  typ->typisarray = (typeStruct->typlen == -1 &&
         typeStruct->typstorage != TYPSTORAGE_PLAIN &&
         OidIsValid(get_base_element_type(typeStruct->typbasetype)));
 }
 else
  typ->typisarray = false;
 typ->atttypmod = typmod;

 /*
  * If it's a named composite type (or domain over one), find the typcache
  * entry and record the current tupdesc ID, so we can detect changes
  * (including drops).  We don't currently support on-the-fly replacement
  * of non-composite types, else we might want to do this for them too.
 */
 if (typ->ttype == PLPGSQL_TTYPE_REC && typ->typoid != RECORDOID)
 {
  TypeCacheEntry *typentry;

  typentry = lookup_type_cache(typ->typoid,
          TYPECACHE_TUPDESC |
          TYPECACHE_DOMAIN_BASE_INFO);
  if (typentry->typtype == TYPTYPE_DOMAIN)
   typentry = lookup_type_cache(typentry->domainBaseType,
           TYPECACHE_TUPDESC);
  if (typentry->tupDesc == NULL)
   ereport(ERROR,
     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
      errmsg("type %s is not composite",
       format_type_be(typ->typoid))));

  typ->origtypname = origtypname;
  typ->tcache = typentry;
  typ->tupdesc_id = typentry->tupDesc_identifier;
 }
 else
 {
  typ->origtypname = NULL;
  typ->tcache = NULL;
  typ->tupdesc_id = 0;
 }

 return typ;
}

/*
 * Build an array type for the element type specified as argument.
 */
PLpgSQL_type *
plpgsql_build_datatype_arrayof(PLpgSQL_type *dtype)
{
 Oid   array_typeid;

 /*
  * If it's already an array type, use it as-is: Postgres doesn't do nested
  * arrays.
 */
 if (dtype->typisarray)
  return dtype;

 array_typeid = get_array_type(dtype->typoid);
 if (!OidIsValid(array_typeid))
  ereport(ERROR,
    (errcode(ERRCODE_UNDEFINED_OBJECT),
     errmsg("could not find array type for data type %s",
      format_type_be(dtype->typoid))));

 /* Note we inherit typmod and collation, if any, from the element type */
 return plpgsql_build_datatype(array_typeid, dtype->atttypmod,
          dtype->collation, NULL);
}

/*
 * plpgsql_recognize_err_condition
 *  Check condition name and translate it to SQLSTATE.
 *
 * Note: there are some cases where the same condition name has multiple
 * entries in the table.  We arbitrarily return the first match.
 */
int
plpgsql_recognize_err_condition(const char *condname, bool allow_sqlstate)
{
 int   i;

 if (allow_sqlstate)
 {
  if (strlen(condname) == 5 &&
   strspn(condname, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") == 5)
   return MAKE_SQLSTATE(condname[0],
         condname[1],
         condname[2],
         condname[3],
         condname[4]);
 }

 for (i = 0; exception_label_map[i].label != NULL; i++)
 {
  if (strcmp(condname, exception_label_map[i].label) == 0)
   return exception_label_map[i].sqlerrstate;
 }

 ereport(ERROR,
   (errcode(ERRCODE_UNDEFINED_OBJECT),
    errmsg("unrecognized exception condition \"%s\"",
     condname)));
 return 0;     /* keep compiler quiet */
}

/*
 * plpgsql_parse_err_condition
 *  Generate PLpgSQL_condition entry(s) for an exception condition name
 *
 * This has to be able to return a list because there are some duplicate
 * names in the table of error code names.
 */
PLpgSQL_condition *
plpgsql_parse_err_condition(char *condname)
{
 int   i;
 PLpgSQL_condition *new;
 PLpgSQL_condition *prev;

 /*
  * XXX Eventually we will want to look for user-defined exception names
  * here.
 */

 if (strcmp(condname, "others") == 0)
 {
  new = palloc(sizeof(PLpgSQL_condition));
  new->sqlerrstate = PLPGSQL_OTHERS;
  new->condname = condname;
  new->next = NULL;
  return new;
 }

 prev = NULL;
 for (i = 0; exception_label_map[i].label != NULL; i++)
 {
  if (strcmp(condname, exception_label_map[i].label) == 0)
  {
   new = palloc(sizeof(PLpgSQL_condition));
   new->sqlerrstate = exception_label_map[i].sqlerrstate;
   new->condname = condname;
   new->next = prev;
   prev = new;
  }
 }

 if (!prev)
  ereport(ERROR,
    (errcode(ERRCODE_UNDEFINED_OBJECT),
     errmsg("unrecognized exception condition \"%s\"",
      condname)));

 return prev;
}

/* ----------
 * plpgsql_start_datums   Initialize datum list at compile startup.
 * ----------
 */
static void
plpgsql_start_datums(void)
{
 datums_alloc = 128;
 plpgsql_nDatums = 0;
 /* This is short-lived, so needn't allocate in function's cxt */
 plpgsql_Datums = MemoryContextAlloc(plpgsql_compile_tmp_cxt,
          sizeof(PLpgSQL_datum *) * datums_alloc);
 /* datums_last tracks what's been seen by plpgsql_add_initdatums() */
 datums_last = 0;
}

/* ----------
 * plpgsql_adddatum   Add a variable, record or row
 *     to the compiler's datum list.
 * ----------
 */
void
plpgsql_adddatum(PLpgSQL_datum *newdatum)
{
 if (plpgsql_nDatums == datums_alloc)
 {
  datums_alloc *= 2;
  plpgsql_Datums = repalloc(plpgsql_Datums, sizeof(PLpgSQL_datum *) * datums_alloc);
 }

 newdatum->dno = plpgsql_nDatums;
 plpgsql_Datums[plpgsql_nDatums++] = newdatum;
}

/* ----------
 * plpgsql_finish_datums Copy completed datum info into function struct.
 * ----------
 */
static void
plpgsql_finish_datums(PLpgSQL_function *function)
{
 Size  copiable_size = 0;
 int   i;

 function->ndatums = plpgsql_nDatums;
 function->datums = palloc(sizeof(PLpgSQL_datum *) * plpgsql_nDatums);
 for (i = 0; i < plpgsql_nDatums; i++)
 {
  function->datums[i] = plpgsql_Datums[i];

  /* This must agree with copy_plpgsql_datums on what is copiable */
  switch (function->datums[i]->dtype)
  {
   case PLPGSQL_DTYPE_VAR:
   case PLPGSQL_DTYPE_PROMISE:
    copiable_size += MAXALIGN(sizeof(PLpgSQL_var));
    break;
   case PLPGSQL_DTYPE_REC:
    copiable_size += MAXALIGN(sizeof(PLpgSQL_rec));
    break;
   default:
    break;
  }
 }
 function->copiable_size = copiable_size;
}


/* ----------
 * plpgsql_add_initdatums  Make an array of the datum numbers of
 *     all the initializable datums created since the last call
 *     to this function.
 *
 * If varnos is NULL, we just forget any datum entries created since the
 * last call.
 *
 * This is used around a DECLARE section to create a list of the datums
 * that have to be initialized at block entry.  Note that datums can also
 * be created elsewhere than DECLARE, eg by a FOR-loop, but it is then
 * the responsibility of special-purpose code to initialize them.
 * ----------
 */
int
plpgsql_add_initdatums(int **varnos)
{
 int   i;
 int   n = 0;

 /*
  * The set of dtypes recognized here must match what exec_stmt_block()
  * cares about (re)initializing at block entry.
 */
 for (i = datums_last; i < plpgsql_nDatums; i++)
 {
  switch (plpgsql_Datums[i]->dtype)
  {
   case PLPGSQL_DTYPE_VAR:
   case PLPGSQL_DTYPE_REC:
    n++;
    break;

   default:
    break;
  }
 }

 if (varnos != NULL)
 {
  if (n > 0)
  {
   *varnos = (int *) palloc(sizeof(int) * n);

   n = 0;
   for (i = datums_last; i < plpgsql_nDatums; i++)
   {
    switch (plpgsql_Datums[i]->dtype)
    {
     case PLPGSQL_DTYPE_VAR:
     case PLPGSQL_DTYPE_REC:
      (*varnos)[n++] = plpgsql_Datums[i]->dno;

     default:
      break;
    }
   }
  }
  else
   *varnos = NULL;
 }

 datums_last = plpgsql_nDatums;
 return n;
}