#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_type.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/rel.h"
#include "utils/syscache.h"
#include "utils/typcache.h"
#include "plerrcodes.h"

Include dependency graph for pl_comp.c:

Data Structures
struct	plpgsql_hashent

struct	ExceptionLabelMap

Macros
#define	FUNCS_PER_USER 128 /* initial table size */

Typedefs
typedef struct plpgsql_hashent	plpgsql_HashEnt

Functions
static PLpgSQL_function *	do_compile (FunctionCallInfo fcinfo, HeapTuple procTup, PLpgSQL_function function, PLpgSQL_func_hashkey hashkey, 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)

static void	compute_function_hashkey (FunctionCallInfo fcinfo, Form_pg_proc procStruct, PLpgSQL_func_hashkey *hashkey, bool forValidator)

static void	plpgsql_resolve_polymorphic_argtypes (int numargs, Oid argtypes, char argmodes, Node call_expr, bool forValidator, const char proname)

static PLpgSQL_function *	plpgsql_HashTableLookup (PLpgSQL_func_hashkey *func_key)

static void	plpgsql_HashTableInsert (PLpgSQL_function function, PLpgSQL_func_hashkey func_key)

static void	plpgsql_HashTableDelete (PLpgSQL_function *function)

static void	delete_function (PLpgSQL_function *func)

PLpgSQL_function *	plpgsql_compile (FunctionCallInfo fcinfo, bool forValidator)

PLpgSQL_function *	plpgsql_compile_inline (char *proc_source)

void	plpgsql_parser_setup (struct ParseState pstate, PLpgSQL_expr expr)

bool	plpgsql_parse_word (char word1, const char yytxt, bool lookup, PLwdatum wdatum, PLword word)

bool	plpgsql_parse_dblword (char word1, char word2, PLwdatum wdatum, PLcword cword)

bool	plpgsql_parse_tripword (char word1, char word2, char word3, PLwdatum wdatum, PLcword *cword)

PLpgSQL_type *	plpgsql_parse_wordtype (char *ident)

PLpgSQL_type *	plpgsql_parse_cwordtype (List *idents)

PLpgSQL_type *	plpgsql_parse_wordrowtype (char *ident)

PLpgSQL_type *	plpgsql_parse_cwordrowtype (List *idents)

PLpgSQL_variable *	plpgsql_build_variable (const char refname, int lineno, PLpgSQL_type dtype, bool add2namespace)

PLpgSQL_rec *	plpgsql_build_record (const char refname, int lineno, PLpgSQL_type dtype, Oid rectypeid, bool add2namespace)

PLpgSQL_recfield *	plpgsql_build_recfield (PLpgSQL_rec rec, const char fldname)

PLpgSQL_type *	plpgsql_build_datatype (Oid typeOid, int32 typmod, Oid collation, TypeName *origtypname)

PLpgSQL_type *	plpgsql_build_datatype_arrayof (PLpgSQL_type *dtype)

int	plpgsql_recognize_err_condition (const char *condname, bool allow_sqlstate)

PLpgSQL_condition *	plpgsql_parse_err_condition (char *condname)

void	plpgsql_adddatum (PLpgSQL_datum *newdatum)

int	plpgsql_add_initdatums (int **varnos)

void	plpgsql_HashTableInit (void)

Variables
PLpgSQL_stmt_block *	plpgsql_parse_result

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

MemoryContext	plpgsql_compile_tmp_cxt

static HTAB *	plpgsql_HashTable = NULL

static const ExceptionLabelMap	exception_label_map []

Macro Definition Documentation

◆ FUNCS_PER_USER

#define FUNCS_PER_USER 128 /* initial table size */

Definition at line 70 of file pl_comp.c.

Typedef Documentation

◆ plpgsql_HashEnt

typedef struct plpgsql_hashent plpgsql_HashEnt

Function Documentation

◆ add_dummy_return()

static void add_dummy_return ( PLpgSQL_function * function )

static

Definition at line 1032 of file pl_comp.c.

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

References function, lappend(), list_make1, llast, NIL, palloc0(), PLPGSQL_STMT_BLOCK, and PLPGSQL_STMT_RETURN.

Referenced by do_compile(), and plpgsql_compile_inline().

◆ add_parameter_name()

static void add_parameter_name	(	PLpgSQL_nsitem_type	itemtype,
		int	itemno,
		const char *	name
	)

static

Definition at line 1007 of file pl_comp.c.

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

References ereport, errcode(), errmsg(), ERROR, name, plpgsql_ns_additem(), plpgsql_ns_lookup(), and plpgsql_ns_top().

Referenced by do_compile().

◆ build_datatype()

static PLpgSQL_type * build_datatype	(	HeapTuple	typeTup,
		int32	typmod,
		Oid	collation,
		TypeName *	origtypname
	)

static

Definition at line 2066 of file pl_comp.c.

 {
     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;
 }

References PLpgSQL_type::atttypmod, PLpgSQL_type::collation, TypeCacheEntry::domainBaseType, elog, ereport, errcode(), errmsg(), ERROR, format_type_be(), get_base_element_type(), GETSTRUCT, lookup_type_cache(), NameStr, OidIsValid, PLpgSQL_type::origtypname, palloc(), PLPGSQL_TTYPE_PSEUDO, PLPGSQL_TTYPE_REC, PLPGSQL_TTYPE_SCALAR, pstrdup(), PLpgSQL_type::tcache, PLpgSQL_type::ttype, TypeCacheEntry::tupDesc, PLpgSQL_type::tupdesc_id, TypeCacheEntry::tupDesc_identifier, PLpgSQL_type::typbyval, type_is_rowtype(), TYPECACHE_DOMAIN_BASE_INFO, TYPECACHE_TUPDESC, PLpgSQL_type::typisarray, PLpgSQL_type::typlen, PLpgSQL_type::typname, PLpgSQL_type::typoid, TypeCacheEntry::typtype, and PLpgSQL_type::typtype.

Referenced by do_compile(), plpgsql_build_datatype(), and plpgsql_parse_cwordtype().

◆ build_row_from_vars()

static PLpgSQL_row * build_row_from_vars	(	PLpgSQL_variable **	vars,
		int	numvars
	)

static

Definition at line 1930 of file pl_comp.c.

 {
     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;
 }

References Assert, CreateTemplateTupleDesc(), PLpgSQL_variable::dno, PLpgSQL_variable::dtype, PLpgSQL_row::dtype, elog, ERROR, PLpgSQL_row::fieldnames, i, InvalidOid, PLpgSQL_variable::isconst, PLpgSQL_row::lineno, PLpgSQL_row::nfields, palloc(), palloc0(), PLPGSQL_DTYPE_PROMISE, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_ROW, PLPGSQL_DTYPE_VAR, PLpgSQL_variable::refname, PLpgSQL_row::refname, PLpgSQL_row::rowtupdesc, TupleDescInitEntry(), TupleDescInitEntryCollation(), and PLpgSQL_row::varnos.

Referenced by do_compile().

◆ compute_function_hashkey()

static void compute_function_hashkey	(	FunctionCallInfo	fcinfo,
		Form_pg_proc	procStruct,
		PLpgSQL_func_hashkey *	hashkey,
		bool	forValidator
	)

static

Definition at line 2432 of file pl_comp.c.

 {
     /* Make sure any unused bytes of the struct are zero */
     MemSet(hashkey, 0, sizeof(PLpgSQL_func_hashkey));
  
     /* get function OID */
     hashkey->funcOid = fcinfo->flinfo->fn_oid;
  
     /* get call context */
     hashkey->isTrigger = CALLED_AS_TRIGGER(fcinfo);
     hashkey->isEventTrigger = CALLED_AS_EVENT_TRIGGER(fcinfo);
  
     /*
      * If DML trigger, include trigger's OID in the hash, so that each trigger
      * usage gets a different hash entry, allowing for e.g. different relation
      * rowtypes or transition table names.  In validation mode we do not know
      * what relation or transition table names are intended to be used, so we
      * leave trigOid zero; the hash entry built in this case will never be
      * used for any actual calls.
      *
      * We don't currently need to distinguish different event trigger usages
      * in the same way, since the special parameter variables don't vary in
      * type in that case.
      */
     if (hashkey->isTrigger && !forValidator)
     {
         TriggerData *trigdata = (TriggerData *) fcinfo->context;
  
         hashkey->trigOid = trigdata->tg_trigger->tgoid;
     }
  
     /* get input collation, if known */
     hashkey->inputCollation = fcinfo->fncollation;
  
     if (procStruct->pronargs > 0)
     {
         /* get the argument types */
         memcpy(hashkey->argtypes, procStruct->proargtypes.values,
                procStruct->pronargs * sizeof(Oid));
  
         /* resolve any polymorphic argument types */
         plpgsql_resolve_polymorphic_argtypes(procStruct->pronargs,
                                              hashkey->argtypes,
                                              NULL,
                                              fcinfo->flinfo->fn_expr,
                                              forValidator,
                                              NameStr(procStruct->proname));
     }
 }

References PLpgSQL_func_hashkey::argtypes, CALLED_AS_EVENT_TRIGGER, CALLED_AS_TRIGGER, FunctionCallInfoBaseData::context, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_expr, FmgrInfo::fn_oid, FunctionCallInfoBaseData::fncollation, PLpgSQL_func_hashkey::funcOid, PLpgSQL_func_hashkey::inputCollation, PLpgSQL_func_hashkey::isEventTrigger, PLpgSQL_func_hashkey::isTrigger, MemSet, NameStr, plpgsql_resolve_polymorphic_argtypes(), TriggerData::tg_trigger, Trigger::tgoid, and PLpgSQL_func_hashkey::trigOid.

Referenced by plpgsql_compile().

◆ delete_function()

static void delete_function ( PLpgSQL_function * func )

static

Definition at line 2583 of file pl_comp.c.

 {
     /* remove function from hash table (might be done already) */
     plpgsql_HashTableDelete(func);
  
     /* release the function's storage if safe and not done already */
     if (func->use_count == 0)
         plpgsql_free_function_memory(func);
 }

References plpgsql_free_function_memory(), plpgsql_HashTableDelete(), and PLpgSQL_function::use_count.

Referenced by plpgsql_compile().

◆ do_compile()

static PLpgSQL_function * do_compile	(	FunctionCallInfo	fcinfo,
		HeapTuple	procTup,
		PLpgSQL_function *	function,
		PLpgSQL_func_hashkey *	hashkey,
		bool	forValidator
	)

static

Definition at line 264 of file pl_comp.c.

 {
     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);
     Datum       prosrcdatum;
     char       *proc_source;
     HeapTuple   typeTup;
     Form_pg_type typeStruct;
     PLpgSQL_variable *var;
     PLpgSQL_rec *rec;
     int         i;
     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.  We assume that this function
      * cannot be invoked recursively, so there's no need to save and restore
      * the static variables used here.
      */
     prosrcdatum = SysCacheGetAttrNotNull(PROCOID, procTup, Anum_pg_proc_prosrc);
     proc_source = TextDatumGetCString(prosrcdatum);
     plpgsql_scanner_init(proc_source);
  
     plpgsql_error_funcname = pstrdup(NameStr(procStruct->proname));
  
     /*
      * Setup error traceback support for ereport()
      */
     plerrcontext.callback = plpgsql_compile_error_callback;
     plerrcontext.arg = forValidator ? proc_source : NULL;
     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;
  
     /*
      * Create the new function struct, if not done already.  The function
      * structs are never thrown away, so keep them in TopMemoryContext.
      */
     if (function == NULL)
     {
         function = (PLpgSQL_function *)
             MemoryContextAllocZero(TopMemoryContext, sizeof(PLpgSQL_function));
     }
     else
     {
         /* re-using a previously existing struct, so clear it out */
         memset(function, 0, sizeof(PLpgSQL_function));
     }
     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.
      */
     func_cxt = AllocSetContextCreate(TopMemoryContext,
                                      "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_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
     function->fn_tid = procTup->t_self;
     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;
  
     /*
      * 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);
  
             plpgsql_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();
     if (parse_rc != 0)
         elog(ERROR, "plpgsql parser returned %d", parse_rc);
     function->action = plpgsql_parse_result;
  
     plpgsql_scanner_finish();
     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);
  
     /* Debug dump for completed functions */
     if (plpgsql_DumpExecTree)
         plpgsql_dumptree(function);
  
     /*
      * add it to the hash table
      */
     plpgsql_HashTableInsert(function, hashkey);
  
     /*
      * 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;
 }

Referenced by plpgsql_compile().

◆ make_datum_param()

static Node * make_datum_param	(	PLpgSQL_expr *	expr,
		int	dno,
		int	location
	)

static

Definition at line 1333 of file pl_comp.c.

 {
     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,
                                      &param->paramtype,
                                      &param->paramtypmod,
                                      &param->paramcollid);
     param->location = location;
  
     return (Node *) param;
 }

References Assert, bms_add_member(), PLpgSQL_function::cur_estate, PLpgSQL_execstate::datums, PLpgSQL_function::fn_cxt, PLpgSQL_expr::func, Param::location, makeNode, MemoryContextSwitchTo(), PARAM_EXTERN, Param::paramid, Param::paramkind, PLpgSQL_expr::paramnos, Param::paramtype, and plpgsql_exec_get_datum_type_info().

Referenced by plpgsql_param_ref(), and resolve_column_ref().

◆ plpgsql_add_initdatums()

int plpgsql_add_initdatums ( int ** varnos )

Definition at line 2374 of file pl_comp.c.

 {
     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;
 }

References datums_last, PLpgSQL_datum::dno, i, palloc(), plpgsql_Datums, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_VAR, and plpgsql_nDatums.

◆ plpgsql_adddatum()

void plpgsql_adddatum ( PLpgSQL_datum * newdatum )

Definition at line 2313 of file pl_comp.c.

 {
     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;
 }

References datums_alloc, PLpgSQL_datum::dno, plpgsql_Datums, plpgsql_nDatums, and repalloc().

Referenced by do_compile(), plpgsql_build_recfield(), plpgsql_build_record(), and plpgsql_build_variable().

◆ plpgsql_build_datatype()

PLpgSQL_type* plpgsql_build_datatype	(	Oid	typeOid,
		int32	typmod,
		Oid	collation,
		TypeName *	origtypname
	)

Definition at line 2044 of file pl_comp.c.

 {
     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;
 }

References build_datatype(), elog, ERROR, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), and SearchSysCache1().

Referenced by do_compile(), exec_stmt_case(), plpgsql_build_datatype_arrayof(), plpgsql_compile_inline(), plpgsql_parse_cwordrowtype(), and plpgsql_parse_wordrowtype().

◆ plpgsql_build_datatype_arrayof()

PLpgSQL_type* plpgsql_build_datatype_arrayof ( PLpgSQL_type * dtype )

Definition at line 2178 of file pl_comp.c.

 {
     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);
 }

References PLpgSQL_type::atttypmod, PLpgSQL_type::collation, ereport, errcode(), errmsg(), ERROR, format_type_be(), get_array_type(), OidIsValid, plpgsql_build_datatype(), PLpgSQL_type::typisarray, and PLpgSQL_type::typoid.

◆ plpgsql_build_recfield()

PLpgSQL_recfield* plpgsql_build_recfield	(	PLpgSQL_rec *	rec,
		const char *	fldname
	)

Definition at line 1997 of file pl_comp.c.

 {
     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;
 }

References Assert, PLpgSQL_rec::dno, PLpgSQL_recfield::dno, PLpgSQL_recfield::dtype, PLpgSQL_recfield::fieldname, PLpgSQL_rec::firstfield, i, INVALID_TUPLEDESC_IDENTIFIER, PLpgSQL_recfield::nextfield, palloc0(), plpgsql_adddatum(), plpgsql_Datums, PLPGSQL_DTYPE_RECFIELD, pstrdup(), PLpgSQL_recfield::recparentno, and PLpgSQL_recfield::rectupledescid.

Referenced by plpgsql_parse_dblword(), and plpgsql_parse_tripword().

◆ plpgsql_build_record()

PLpgSQL_rec* plpgsql_build_record	(	const char *	refname,
		int	lineno,
		PLpgSQL_type *	dtype,
		Oid	rectypeid,
		bool	add2namespace
	)

Definition at line 1903 of file pl_comp.c.

 {
     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;
 }

References PLpgSQL_rec::datatype, PLpgSQL_rec::dno, PLpgSQL_rec::dtype, PLpgSQL_rec::erh, PLpgSQL_rec::firstfield, PLpgSQL_rec::lineno, palloc0(), plpgsql_adddatum(), PLPGSQL_DTYPE_REC, plpgsql_ns_additem(), PLPGSQL_NSTYPE_REC, pstrdup(), PLpgSQL_rec::rectypeid, and PLpgSQL_rec::refname.

Referenced by do_compile(), and plpgsql_build_variable().

◆ plpgsql_build_variable()

PLpgSQL_variable* plpgsql_build_variable	(	const char *	refname,
		int	lineno,
		PLpgSQL_type *	dtype,
		bool	add2namespace
	)

Definition at line 1840 of file pl_comp.c.

 {
     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;
 }

References PLpgSQL_var::datatype, PLpgSQL_var::dno, PLpgSQL_var::dtype, elog, ereport, errcode(), errmsg(), ERROR, format_type_be(), PLpgSQL_var::freeval, PLpgSQL_var::isnull, PLpgSQL_var::lineno, palloc0(), plpgsql_adddatum(), plpgsql_build_record(), PLPGSQL_DTYPE_VAR, plpgsql_ns_additem(), PLPGSQL_NSTYPE_VAR, PLPGSQL_TTYPE_PSEUDO, PLPGSQL_TTYPE_REC, PLPGSQL_TTYPE_SCALAR, pstrdup(), PLpgSQL_var::refname, PLpgSQL_type::ttype, PLpgSQL_type::typoid, and PLpgSQL_var::value.

Referenced by do_compile(), and plpgsql_compile_inline().

◆ plpgsql_compile()

PLpgSQL_function* plpgsql_compile	(	FunctionCallInfo	fcinfo,
		bool	forValidator
	)

Definition at line 136 of file pl_comp.c.

 {
     Oid         funcOid = fcinfo->flinfo->fn_oid;
     HeapTuple   procTup;
     Form_pg_proc procStruct;
     PLpgSQL_function *function;
     PLpgSQL_func_hashkey hashkey;
     bool        function_valid = false;
     bool        hashkey_valid = false;
  
     /*
      * Lookup the pg_proc tuple by Oid; we'll need it in any case
      */
     procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcOid));
     if (!HeapTupleIsValid(procTup))
         elog(ERROR, "cache lookup failed for function %u", funcOid);
     procStruct = (Form_pg_proc) GETSTRUCT(procTup);
  
     /*
      * See if there's already a cache entry for the current FmgrInfo. If not,
      * try to find one in the hash table.
      */
     function = (PLpgSQL_function *) fcinfo->flinfo->fn_extra;
  
 recheck:
     if (!function)
     {
         /* Compute hashkey using function signature and actual arg types */
         compute_function_hashkey(fcinfo, procStruct, &hashkey, forValidator);
         hashkey_valid = true;
  
         /* And do the lookup */
         function = plpgsql_HashTableLookup(&hashkey);
     }
  
     if (function)
     {
         /* We have a compiled function, but is it still valid? */
         if (function->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
             ItemPointerEquals(&function->fn_tid, &procTup->t_self))
             function_valid = true;
         else
         {
             /*
              * Nope, so remove it from hashtable and try to drop associated
              * storage (if not done already).
              */
             delete_function(function);
  
             /*
              * If the function isn't in active use then we can overwrite the
              * func struct with new data, allowing any other existing fn_extra
              * pointers to make use of the new definition on their next use.
              * If it is in use then just leave it alone and make a new one.
              * (The active invocations will run to completion using the
              * previous definition, and then the cache entry will just be
              * leaked; doesn't seem worth adding code to clean it up, given
              * what a corner case this is.)
              *
              * If we found the function struct via fn_extra then it's possible
              * a replacement has already been made, so go back and recheck the
              * hashtable.
              */
             if (function->use_count != 0)
             {
                 function = NULL;
                 if (!hashkey_valid)
                     goto recheck;
             }
         }
     }
  
     /*
      * If the function wasn't found or was out-of-date, we have to compile it
      */
     if (!function_valid)
     {
         /*
          * Calculate hashkey if we didn't already; we'll need it to store the
          * completed function.
          */
         if (!hashkey_valid)
             compute_function_hashkey(fcinfo, procStruct, &hashkey,
                                      forValidator);
  
         /*
          * Do the hard part.
          */
         function = do_compile(fcinfo, procTup, function,
                               &hashkey, forValidator);
     }
  
     ReleaseSysCache(procTup);
  
     /*
      * Save pointer in FmgrInfo to avoid search on subsequent calls
      */
     fcinfo->flinfo->fn_extra = (void *) function;
  
     /*
      * Finally return the compiled function
      */
     return function;
 }

References compute_function_hashkey(), delete_function(), do_compile(), elog, ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_oid, function, GETSTRUCT, HeapTupleHeaderGetRawXmin, HeapTupleIsValid, if(), ItemPointerEquals(), ObjectIdGetDatum(), plpgsql_HashTableLookup(), ReleaseSysCache(), SearchSysCache1(), HeapTupleData::t_data, and HeapTupleData::t_self.

Referenced by plpgsql_call_handler(), and plpgsql_validator().

◆ plpgsql_compile_error_callback()

static void plpgsql_compile_error_callback ( void * arg )

static

Definition at line 980 of file pl_comp.c.

 {
     if (arg)
     {
         /*
          * Try to convert syntax error position to reference text of original
          * CREATE FUNCTION or DO command.
          */
         if (function_parse_error_transpose((const char *) arg))
             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());
 }

References arg, errcontext, function_parse_error_transpose(), plpgsql_error_funcname, and plpgsql_latest_lineno().

Referenced by do_compile(), and plpgsql_compile_inline().

◆ plpgsql_compile_inline()

PLpgSQL_function* plpgsql_compile_inline ( char * proc_source )

Definition at line 843 of file pl_comp.c.

 {
     char       *func_name = "inline_code_block";
     PLpgSQL_function *function;
     ErrorContextCallback plerrcontext;
     PLpgSQL_variable *var;
     int         parse_rc;
     MemoryContext func_cxt;
  
     /*
      * Setup the scanner input and error info.  We assume that this function
      * cannot be invoked recursively, so there's no need to save and restore
      * the static variables used here.
      */
     plpgsql_scanner_init(proc_source);
  
     plpgsql_error_funcname = func_name;
  
     /*
      * Setup error traceback support for ereport()
      */
     plerrcontext.callback = plpgsql_compile_error_callback;
     plerrcontext.arg = proc_source;
     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;
  
     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();
     if (parse_rc != 0)
         elog(ERROR, "plpgsql parser returned %d", parse_rc);
     function->action = plpgsql_parse_result;
  
     plpgsql_scanner_finish();
  
     /*
      * 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);
  
     /*
      * 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;
 }

References add_dummy_return(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ErrorContextCallback::arg, ErrorContextCallback::callback, check_function_bodies, CurrentMemoryContext, PLpgSQL_variable::dno, elog, ERROR, error_context_stack, function, InvalidOid, MemoryContextSwitchTo(), palloc0(), plpgsql_build_datatype(), plpgsql_build_variable(), plpgsql_check_syntax, plpgsql_compile_error_callback(), plpgsql_compile_tmp_cxt, plpgsql_curr_compile, plpgsql_DumpExecTree, plpgsql_error_funcname, plpgsql_finish_datums(), PLPGSQL_LABEL_BLOCK, PLPGSQL_NOT_TRIGGER, plpgsql_ns_init(), plpgsql_ns_push(), plpgsql_parse_result, plpgsql_print_strict_params, plpgsql_scanner_finish(), plpgsql_scanner_init(), plpgsql_start_datums(), plpgsql_variable_conflict, plpgsql_yyparse(), ErrorContextCallback::previous, and pstrdup().

Referenced by plpgsql_inline_handler().

◆ plpgsql_finish_datums()

static void plpgsql_finish_datums ( PLpgSQL_function * function )

static

Definition at line 2330 of file pl_comp.c.

 {
     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;
 }

References function, i, MAXALIGN, palloc(), plpgsql_Datums, PLPGSQL_DTYPE_PROMISE, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_VAR, and plpgsql_nDatums.

Referenced by do_compile(), and plpgsql_compile_inline().

◆ plpgsql_HashTableDelete()

static void plpgsql_HashTableDelete ( PLpgSQL_function * function )

static

Definition at line 2645 of file pl_comp.c.

 {
     plpgsql_HashEnt *hentry;
  
     /* do nothing if not in table */
     if (function->fn_hashkey == NULL)
         return;
  
     hentry = (plpgsql_HashEnt *) hash_search(plpgsql_HashTable,
                                              function->fn_hashkey,
                                              HASH_REMOVE,
                                              NULL);
     if (hentry == NULL)
         elog(WARNING, "trying to delete function that does not exist");
  
     /* remove back link, which no longer points to allocated storage */
     function->fn_hashkey = NULL;
 }

References elog, function, HASH_REMOVE, hash_search(), plpgsql_HashTable, and WARNING.

Referenced by delete_function().

◆ plpgsql_HashTableInit()

void plpgsql_HashTableInit ( void )

Definition at line 2595 of file pl_comp.c.

 {
     HASHCTL     ctl;
  
     /* don't allow double-initialization */
     Assert(plpgsql_HashTable == NULL);
  
     ctl.keysize = sizeof(PLpgSQL_func_hashkey);
     ctl.entrysize = sizeof(plpgsql_HashEnt);
     plpgsql_HashTable = hash_create("PLpgSQL function hash",
                                     FUNCS_PER_USER,
                                     &ctl,
                                     HASH_ELEM | HASH_BLOBS);
 }

References Assert, ctl, FUNCS_PER_USER, HASH_BLOBS, hash_create(), HASH_ELEM, and plpgsql_HashTable.

Referenced by _PG_init().

◆ plpgsql_HashTableInsert()

static void plpgsql_HashTableInsert	(	PLpgSQL_function *	function,
		PLpgSQL_func_hashkey *	func_key
	)

static

Definition at line 2626 of file pl_comp.c.

 {
     plpgsql_HashEnt *hentry;
     bool        found;
  
     hentry = (plpgsql_HashEnt *) hash_search(plpgsql_HashTable,
                                              func_key,
                                              HASH_ENTER,
                                              &found);
     if (found)
         elog(WARNING, "trying to insert a function that already exists");
  
     hentry->function = function;
     /* prepare back link from function to hashtable key */
     function->fn_hashkey = &hentry->key;
 }

References elog, PLpgSQL_function::fn_hashkey, plpgsql_hashent::function, HASH_ENTER, hash_search(), plpgsql_hashent::key, plpgsql_HashTable, and WARNING.

Referenced by do_compile().

◆ plpgsql_HashTableLookup()

static PLpgSQL_function * plpgsql_HashTableLookup ( PLpgSQL_func_hashkey * func_key )

static

Definition at line 2611 of file pl_comp.c.

 {
     plpgsql_HashEnt *hentry;
  
     hentry = (plpgsql_HashEnt *) hash_search(plpgsql_HashTable,
                                              func_key,
                                              HASH_FIND,
                                              NULL);
     if (hentry)
         return hentry->function;
     else
         return NULL;
 }

References plpgsql_hashent::function, HASH_FIND, hash_search(), and plpgsql_HashTable.

Referenced by plpgsql_compile().

◆ plpgsql_param_ref()

static Node * plpgsql_param_ref	(	ParseState *	pstate,
		ParamRef *	pref
	)

static

Definition at line 1148 of file pl_comp.c.

 {
     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);
 }

References ParamRef::location, make_datum_param(), PLpgSQL_expr::ns, ParamRef::number, ParseState::p_ref_hook_state, plpgsql_ns_lookup(), and snprintf.

Referenced by plpgsql_parser_setup().

◆ plpgsql_parse_cwordrowtype()

PLpgSQL_type* plpgsql_parse_cwordrowtype ( List * idents )

Definition at line 1796 of file pl_comp.c.

 {
     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));
 }

References ereport, errcode(), errmsg(), ERROR, get_rel_type_id(), InvalidOid, makeRangeVarFromNameList(), makeTypeNameFromNameList(), MemoryContextSwitchTo(), NoLock, OidIsValid, plpgsql_build_datatype(), plpgsql_compile_tmp_cxt, RangeVarGetRelid, and RangeVar::relname.

◆ plpgsql_parse_cwordtype()

PLpgSQL_type* plpgsql_parse_cwordtype ( List * idents )

Definition at line 1647 of file pl_comp.c.

 {
     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;
 }

References Assert, build_datatype(), elog, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, linitial, list_copy(), list_delete_last(), list_length(), llast, lsecond, makeRangeVar(), makeRangeVarFromNameList(), MemoryContextSwitchTo(), NoLock, ObjectIdGetDatum(), plpgsql_compile_tmp_cxt, plpgsql_Datums, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, PLPGSQL_NSTYPE_VAR, RangeVarGetRelid, ReleaseSysCache(), RangeVar::relname, SearchSysCache1(), SearchSysCacheAttName(), and strVal.

◆ plpgsql_parse_dblword()

bool plpgsql_parse_dblword	(	char *	word1,
		char *	word2,
		PLwdatum *	wdatum,
		PLcword *	cword
	)

Definition at line 1441 of file pl_comp.c.

 {
     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;
 }

References PLwdatum::datum, PLwdatum::ident, IDENTIFIER_LOOKUP_DECLARE, PLcword::idents, PLwdatum::idents, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, list_make2, makeString(), plpgsql_build_recfield(), plpgsql_Datums, plpgsql_IdentifierLookup, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, PLPGSQL_NSTYPE_VAR, and PLwdatum::quoted.

Referenced by plpgsql_yylex().

◆ plpgsql_parse_err_condition()

PLpgSQL_condition* plpgsql_parse_err_condition ( char * condname )

Definition at line 2245 of file pl_comp.c.

 {
     int         i;
     PLpgSQL_condition *new;
     PLpgSQL_condition *prev;
  
     /*
      * XXX Eventually we will want to look for user-defined exception names
      * here.
      */
  
     /*
      * OTHERS is represented as code 0 (which would map to '00000', but we
      * have no need to represent that as an exception condition).
      */
     if (strcmp(condname, "others") == 0)
     {
         new = palloc(sizeof(PLpgSQL_condition));
         new->sqlerrstate = 0;
         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;
 }

References ereport, errcode(), errmsg(), ERROR, exception_label_map, i, label, ExceptionLabelMap::label, palloc(), and ExceptionLabelMap::sqlerrstate.

◆ plpgsql_parse_tripword()

bool plpgsql_parse_tripword	(	char *	word1,
		char *	word2,
		char *	word3,
		PLwdatum *	wdatum,
		PLcword *	cword
	)

Definition at line 1522 of file pl_comp.c.

 {
     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;
 }

References PLwdatum::datum, PLwdatum::ident, IDENTIFIER_LOOKUP_DECLARE, PLcword::idents, PLwdatum::idents, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, list_make2, list_make3, makeString(), plpgsql_build_recfield(), plpgsql_Datums, plpgsql_IdentifierLookup, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, and PLwdatum::quoted.

Referenced by plpgsql_yylex().

◆ plpgsql_parse_word()

bool plpgsql_parse_word	(	char *	word1,
		const char *	yytxt,
		bool	lookup,
		PLwdatum *	wdatum,
		PLword *	word
	)

Definition at line 1386 of file pl_comp.c.

 {
     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;
 }

References PLwdatum::datum, elog, ERROR, PLwdatum::ident, IDENTIFIER_LOOKUP_NORMAL, PLwdatum::idents, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, NIL, plpgsql_Datums, plpgsql_IdentifierLookup, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, PLPGSQL_NSTYPE_VAR, PLwdatum::quoted, and word().

Referenced by plpgsql_yylex().

◆ plpgsql_parse_wordrowtype()

PLpgSQL_type* plpgsql_parse_wordrowtype ( char * ident )

Definition at line 1759 of file pl_comp.c.

 {
     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));
 }

References ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, get_rel_type_id(), ident, InvalidOid, makeTypeName(), OidIsValid, plpgsql_build_datatype(), and RelnameGetRelid().

◆ plpgsql_parse_wordtype()

PLpgSQL_type* plpgsql_parse_wordtype ( char * ident )

Definition at line 1606 of file pl_comp.c.

 {
     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 */
 }

References ereport, errcode(), errmsg(), ERROR, ident, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, plpgsql_Datums, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, and PLPGSQL_NSTYPE_VAR.

◆ plpgsql_parser_setup()

void plpgsql_parser_setup	(	struct ParseState *	pstate,
		PLpgSQL_expr *	expr
	)

Definition at line 1077 of file pl_comp.c.

 {
     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 = (void *) expr;
 }

References ParseState::p_paramref_hook, ParseState::p_post_columnref_hook, ParseState::p_pre_columnref_hook, ParseState::p_ref_hook_state, plpgsql_param_ref(), plpgsql_post_column_ref(), and plpgsql_pre_column_ref().

Referenced by exec_prepare_plan(), and plpgsql_estate_setup().

◆ plpgsql_post_column_ref()

static Node * plpgsql_post_column_ref	(	ParseState *	pstate,
		ColumnRef *	cref,
		Node *	var
	)

static

Definition at line 1104 of file pl_comp.c.

 {
     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;
 }

References ereport, errcode(), errdetail(), errmsg(), ERROR, ColumnRef::fields, PLpgSQL_expr::func, if(), ColumnRef::location, NameListToString(), ParseState::p_ref_hook_state, parser_errposition(), PLPGSQL_RESOLVE_COLUMN, PLPGSQL_RESOLVE_VARIABLE, resolve_column_ref(), and PLpgSQL_function::resolve_option.

Referenced by plpgsql_parser_setup().

◆ plpgsql_pre_column_ref()

static Node * plpgsql_pre_column_ref	(	ParseState *	pstate,
		ColumnRef *	cref
	)

static

Definition at line 1090 of file pl_comp.c.

 {
     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;
 }

References PLpgSQL_expr::func, if(), ParseState::p_ref_hook_state, PLPGSQL_RESOLVE_VARIABLE, resolve_column_ref(), and PLpgSQL_function::resolve_option.

Referenced by plpgsql_parser_setup().

◆ plpgsql_recognize_err_condition()

int plpgsql_recognize_err_condition	(	const char *	condname,
		bool	allow_sqlstate
	)

Definition at line 2209 of file pl_comp.c.

 {
     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 */
 }

References ereport, errcode(), errmsg(), ERROR, exception_label_map, i, label, ExceptionLabelMap::label, MAKE_SQLSTATE, and ExceptionLabelMap::sqlerrstate.

Referenced by exec_stmt_raise().

◆ plpgsql_resolve_polymorphic_argtypes()

static void plpgsql_resolve_polymorphic_argtypes	(	int	numargs,
		Oid *	argtypes,
		char *	argmodes,
		Node *	call_expr,
		bool	forValidator,
		const char *	proname
	)

static

Definition at line 2498 of file pl_comp.c.

 {
     int         i;
  
     if (!forValidator)
     {
         int         inargno;
  
         /* normal case, pass to standard routine */
         if (!resolve_polymorphic_argtypes(numargs, argtypes, argmodes,
                                           call_expr))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("could not determine actual argument "
                             "type for polymorphic function \"%s\"",
                             proname)));
         /* also, treat RECORD inputs (but not outputs) as polymorphic */
         inargno = 0;
         for (i = 0; i < numargs; i++)
         {
             char        argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
  
             if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                 continue;
             if (argtypes[i] == RECORDOID || argtypes[i] == RECORDARRAYOID)
             {
                 Oid         resolvedtype = get_call_expr_argtype(call_expr,
                                                                  inargno);
  
                 if (OidIsValid(resolvedtype))
                     argtypes[i] = resolvedtype;
             }
             inargno++;
         }
     }
     else
     {
         /* special validation case (no need to do anything for RECORD) */
         for (i = 0; i < numargs; i++)
         {
             switch (argtypes[i])
             {
                 case ANYELEMENTOID:
                 case ANYNONARRAYOID:
                 case ANYENUMOID:    /* XXX dubious */
                 case ANYCOMPATIBLEOID:
                 case ANYCOMPATIBLENONARRAYOID:
                     argtypes[i] = INT4OID;
                     break;
                 case ANYARRAYOID:
                 case ANYCOMPATIBLEARRAYOID:
                     argtypes[i] = INT4ARRAYOID;
                     break;
                 case ANYRANGEOID:
                 case ANYCOMPATIBLERANGEOID:
                     argtypes[i] = INT4RANGEOID;
                     break;
                 case ANYMULTIRANGEOID:
                     argtypes[i] = INT4MULTIRANGEOID;
                     break;
                 default:
                     break;
             }
         }
     }
 }

References ereport, errcode(), errmsg(), ERROR, get_call_expr_argtype(), i, OidIsValid, proname, and resolve_polymorphic_argtypes().

Referenced by compute_function_hashkey(), and do_compile().

◆ plpgsql_start_datums()

static void plpgsql_start_datums ( void )

static

Definition at line 2296 of file pl_comp.c.

 {
     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;
 }

References datums_alloc, datums_last, MemoryContextAlloc(), plpgsql_compile_tmp_cxt, plpgsql_Datums, and plpgsql_nDatums.

Referenced by do_compile(), and plpgsql_compile_inline().

◆ resolve_column_ref()

static Node * resolve_column_ref	(	ParseState *	pstate,
		PLpgSQL_expr *	expr,
		ColumnRef *	cref,
		bool	error_if_no_field
	)

static

Definition at line 1175 of file pl_comp.c.

 {
     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;
 }

References Assert, PLpgSQL_function::cur_estate, PLpgSQL_execstate::datums, PLpgSQL_recfield::dtype, elog, ereport, errcode(), errmsg(), ERROR, PLpgSQL_recfield::fieldname, ColumnRef::fields, PLpgSQL_rec::firstfield, PLpgSQL_expr::func, i, IsA, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, linitial, list_length(), ColumnRef::location, lsecond, lthird, make_datum_param(), PLpgSQL_recfield::nextfield, PLpgSQL_expr::ns, parser_errposition(), PLPGSQL_DTYPE_RECFIELD, plpgsql_ns_lookup(), PLPGSQL_NSTYPE_REC, PLPGSQL_NSTYPE_VAR, PLpgSQL_recfield::recparentno, strVal, and while().

Referenced by plpgsql_post_column_ref(), and plpgsql_pre_column_ref().

Variable Documentation

◆ datums_alloc

int datums_alloc

static

Definition at line 44 of file pl_comp.c.

Referenced by plpgsql_adddatum(), and plpgsql_start_datums().

◆ datums_last

int datums_last

static

Definition at line 47 of file pl_comp.c.

Referenced by plpgsql_add_initdatums(), and plpgsql_start_datums().

◆ exception_label_map

const ExceptionLabelMap exception_label_map[]

static

Initial value:

= {
            
    {NULL, 0}
}

Definition at line 82 of file pl_comp.c.

Referenced by plpgsql_parse_err_condition(), and plpgsql_recognize_err_condition().

◆ plpgsql_check_syntax

bool plpgsql_check_syntax = false

Definition at line 51 of file pl_comp.c.

Referenced by do_compile(), and plpgsql_compile_inline().

◆ plpgsql_compile_tmp_cxt

MemoryContext plpgsql_compile_tmp_cxt

Definition at line 56 of file pl_comp.c.

Referenced by do_compile(), plpgsql_compile_inline(), plpgsql_parse_cwordrowtype(), plpgsql_parse_cwordtype(), and plpgsql_start_datums().

◆ plpgsql_curr_compile

PLpgSQL_function* plpgsql_curr_compile

Definition at line 53 of file pl_comp.c.

Referenced by do_compile(), and plpgsql_compile_inline().

◆ plpgsql_Datums

PLpgSQL_datum** plpgsql_Datums

Definition at line 46 of file pl_comp.c.

Referenced by plpgsql_add_initdatums(), plpgsql_adddatum(), plpgsql_build_recfield(), plpgsql_finish_datums(), plpgsql_parse_cwordtype(), plpgsql_parse_dblword(), plpgsql_parse_tripword(), plpgsql_parse_word(), plpgsql_parse_wordtype(), and plpgsql_start_datums().

◆ plpgsql_DumpExecTree

bool plpgsql_DumpExecTree = false

Definition at line 50 of file pl_comp.c.

Referenced by do_compile(), and plpgsql_compile_inline().

◆ plpgsql_error_funcname

char* plpgsql_error_funcname

Definition at line 49 of file pl_comp.c.

Referenced by do_compile(), plpgsql_compile_error_callback(), and plpgsql_compile_inline().

◆ plpgsql_HashTable

HTAB* plpgsql_HashTable = NULL

static

Definition at line 62 of file pl_comp.c.

Referenced by plpgsql_HashTableDelete(), plpgsql_HashTableInit(), plpgsql_HashTableInsert(), and plpgsql_HashTableLookup().

◆ plpgsql_nDatums

int plpgsql_nDatums

Definition at line 45 of file pl_comp.c.

Referenced by plpgsql_add_initdatums(), plpgsql_adddatum(), plpgsql_finish_datums(), and plpgsql_start_datums().

◆ plpgsql_parse_result

PLpgSQL_stmt_block* plpgsql_parse_result

Definition at line 42 of file pl_comp.c.

Referenced by do_compile(), and plpgsql_compile_inline().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ FUNCS_PER_USER

Typedef Documentation

◆ plpgsql_HashEnt

Function Documentation

◆ add_dummy_return()

◆ add_parameter_name()

◆ build_datatype()

◆ build_row_from_vars()

◆ compute_function_hashkey()

◆ delete_function()

◆ do_compile()

◆ make_datum_param()

◆ plpgsql_add_initdatums()

◆ plpgsql_adddatum()

◆ plpgsql_build_datatype()

◆ plpgsql_build_datatype_arrayof()

◆ plpgsql_build_recfield()

◆ plpgsql_build_record()

◆ plpgsql_build_variable()

◆ plpgsql_compile()

◆ plpgsql_compile_error_callback()

◆ plpgsql_compile_inline()

◆ plpgsql_finish_datums()

◆ plpgsql_HashTableDelete()

◆ plpgsql_HashTableInit()

◆ plpgsql_HashTableInsert()

◆ plpgsql_HashTableLookup()

◆ plpgsql_param_ref()

◆ plpgsql_parse_cwordrowtype()

◆ plpgsql_parse_cwordtype()

◆ plpgsql_parse_dblword()

◆ plpgsql_parse_err_condition()

◆ plpgsql_parse_tripword()

◆ plpgsql_parse_word()

◆ plpgsql_parse_wordrowtype()

◆ plpgsql_parse_wordtype()

◆ plpgsql_parser_setup()

◆ plpgsql_post_column_ref()

◆ plpgsql_pre_column_ref()

◆ plpgsql_recognize_err_condition()

◆ plpgsql_resolve_polymorphic_argtypes()

◆ plpgsql_start_datums()

◆ resolve_column_ref()

Variable Documentation

◆ datums_alloc

◆ datums_last

◆ exception_label_map

◆ plpgsql_check_syntax

◆ plpgsql_compile_tmp_cxt

◆ plpgsql_curr_compile

◆ plpgsql_Datums

◆ plpgsql_DumpExecTree

◆ plpgsql_error_funcname

◆ plpgsql_HashTable

◆ plpgsql_nDatums

◆ plpgsql_parse_result