PostgreSQL Source Code  git master
pl_comp.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * pl_comp.c - Compiler part of the PL/pgSQL
4  * procedural language
5  *
6  * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/pl/plpgsql/src/pl_comp.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 
16 #include "postgres.h"
17 
18 #include <ctype.h>
19 
20 #include "access/htup_details.h"
21 #include "catalog/namespace.h"
22 #include "catalog/pg_proc.h"
23 #include "catalog/pg_type.h"
24 #include "funcapi.h"
25 #include "nodes/makefuncs.h"
26 #include "parser/parse_type.h"
27 #include "plpgsql.h"
28 #include "utils/builtins.h"
29 #include "utils/guc.h"
30 #include "utils/lsyscache.h"
31 #include "utils/memutils.h"
32 #include "utils/regproc.h"
33 #include "utils/rel.h"
34 #include "utils/syscache.h"
35 #include "utils/typcache.h"
36 
37 /* ----------
38  * Our own local and global variables
39  * ----------
40  */
41 PLpgSQL_stmt_block *plpgsql_parse_result;
42 
43 static int datums_alloc;
44 int plpgsql_nDatums;
45 PLpgSQL_datum **plpgsql_Datums;
46 static int datums_last;
47 
48 char *plpgsql_error_funcname;
49 bool plpgsql_DumpExecTree = false;
50 bool plpgsql_check_syntax = false;
51 
52 PLpgSQL_function *plpgsql_curr_compile;
53 
54 /* A context appropriate for short-term allocs during compilation */
55 MemoryContext plpgsql_compile_tmp_cxt;
56 
57 /* ----------
58  * Hash table for compiled functions
59  * ----------
60  */
61 static HTAB *plpgsql_HashTable = NULL;
62 
63 typedef struct plpgsql_hashent
64 {
65  PLpgSQL_func_hashkey key;
66  PLpgSQL_function *function;
67 } plpgsql_HashEnt;
68 
69 #define FUNCS_PER_USER 128 /* initial table size */
70 
71 /* ----------
72  * Lookup table for EXCEPTION condition names
73  * ----------
74  */
75 typedef struct
76 {
77  const char *label;
78  int sqlerrstate;
79 } ExceptionLabelMap;
80 
81 static const ExceptionLabelMap exception_label_map[] = {
82 #include "plerrcodes.h" /* pgrminclude ignore */
83  {NULL, 0}
84 };
85 
86 
87 /* ----------
88  * static prototypes
89  * ----------
90  */
91 static PLpgSQL_function *do_compile(FunctionCallInfo fcinfo,
92  HeapTuple procTup,
93  PLpgSQL_function *function,
94  PLpgSQL_func_hashkey *hashkey,
95  bool forValidator);
96 static void plpgsql_compile_error_callback(void *arg);
97 static void add_parameter_name(PLpgSQL_nsitem_type itemtype, int itemno, const char *name);
98 static void add_dummy_return(PLpgSQL_function *function);
99 static Node *plpgsql_pre_column_ref(ParseState *pstate, ColumnRef *cref);
100 static Node *plpgsql_post_column_ref(ParseState *pstate, ColumnRef *cref, Node *var);
101 static Node *plpgsql_param_ref(ParseState *pstate, ParamRef *pref);
102 static Node *resolve_column_ref(ParseState *pstate, PLpgSQL_expr *expr,
103  ColumnRef *cref, bool error_if_no_field);
104 static Node *make_datum_param(PLpgSQL_expr *expr, int dno, int location);
105 static PLpgSQL_row *build_row_from_vars(PLpgSQL_variable **vars, int numvars);
106 static PLpgSQL_type *build_datatype(HeapTuple typeTup, int32 typmod,
107  Oid collation, TypeName *origtypname);
108 static void plpgsql_start_datums(void);
109 static void plpgsql_finish_datums(PLpgSQL_function *function);
110 static void compute_function_hashkey(FunctionCallInfo fcinfo,
111  Form_pg_proc procStruct,
112  PLpgSQL_func_hashkey *hashkey,
113  bool forValidator);
114 static void plpgsql_resolve_polymorphic_argtypes(int numargs,
115  Oid *argtypes, char *argmodes,
116  Node *call_expr, bool forValidator,
117  const char *proname);
118 static PLpgSQL_function *plpgsql_HashTableLookup(PLpgSQL_func_hashkey *func_key);
119 static void plpgsql_HashTableInsert(PLpgSQL_function *function,
120  PLpgSQL_func_hashkey *func_key);
121 static void plpgsql_HashTableDelete(PLpgSQL_function *function);
122 static void delete_function(PLpgSQL_function *func);
123 
124 /* ----------
125  * plpgsql_compile Make an execution tree for a PL/pgSQL function.
126  *
127  * If forValidator is true, we're only compiling for validation purposes,
128  * and so some checks are skipped.
129  *
130  * Note: it's important for this to fall through quickly if the function
131  * has already been compiled.
132  * ----------
133  */
134 PLpgSQL_function *
135 plpgsql_compile(FunctionCallInfo fcinfo, bool forValidator)
136 {
137  Oid funcOid = fcinfo->flinfo->fn_oid;
138  HeapTuple procTup;
139  Form_pg_proc procStruct;
140  PLpgSQL_function *function;
141  PLpgSQL_func_hashkey hashkey;
142  bool function_valid = false;
143  bool hashkey_valid = false;
144 
145  /*
146  * Lookup the pg_proc tuple by Oid; we'll need it in any case
147  */
148  procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcOid));
149  if (!HeapTupleIsValid(procTup))
150  elog(ERROR, "cache lookup failed for function %u", funcOid);
151  procStruct = (Form_pg_proc) GETSTRUCT(procTup);
152 
153  /*
154  * See if there's already a cache entry for the current FmgrInfo. If not,
155  * try to find one in the hash table.
156  */
157  function = (PLpgSQL_function *) fcinfo->flinfo->fn_extra;
158 
159 recheck:
160  if (!function)
161  {
162  /* Compute hashkey using function signature and actual arg types */
163  compute_function_hashkey(fcinfo, procStruct, &hashkey, forValidator);
164  hashkey_valid = true;
165 
166  /* And do the lookup */
167  function = plpgsql_HashTableLookup(&hashkey);
168  }
169 
170  if (function)
171  {
172  /* We have a compiled function, but is it still valid? */
173  if (function->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
174  ItemPointerEquals(&function->fn_tid, &procTup->t_self))
175  function_valid = true;
176  else
177  {
178  /*
179  * Nope, so remove it from hashtable and try to drop associated
180  * storage (if not done already).
181  */
182  delete_function(function);
183 
184  /*
185  * If the function isn't in active use then we can overwrite the
186  * func struct with new data, allowing any other existing fn_extra
187  * pointers to make use of the new definition on their next use.
188  * If it is in use then just leave it alone and make a new one.
189  * (The active invocations will run to completion using the
190  * previous definition, and then the cache entry will just be
191  * leaked; doesn't seem worth adding code to clean it up, given
192  * what a corner case this is.)
193  *
194  * If we found the function struct via fn_extra then it's possible
195  * a replacement has already been made, so go back and recheck the
196  * hashtable.
197  */
198  if (function->use_count != 0)
199  {
200  function = NULL;
201  if (!hashkey_valid)
202  goto recheck;
203  }
204  }
205  }
206 
207  /*
208  * If the function wasn't found or was out-of-date, we have to compile it
209  */
210  if (!function_valid)
211  {
212  /*
213  * Calculate hashkey if we didn't already; we'll need it to store the
214  * completed function.
215  */
216  if (!hashkey_valid)
217  compute_function_hashkey(fcinfo, procStruct, &hashkey,
218  forValidator);
219 
220  /*
221  * Do the hard part.
222  */
223  function = do_compile(fcinfo, procTup, function,
224  &hashkey, forValidator);
225  }
226 
227  ReleaseSysCache(procTup);
228 
229  /*
230  * Save pointer in FmgrInfo to avoid search on subsequent calls
231  */
232  fcinfo->flinfo->fn_extra = (void *) function;
233 
234  /*
235  * Finally return the compiled function
236  */
237  return function;
238 }
239 
240 /*
241  * This is the slow part of plpgsql_compile().
242  *
243  * The passed-in "function" pointer is either NULL or an already-allocated
244  * function struct to overwrite.
245  *
246  * While compiling a function, the CurrentMemoryContext is the
247  * per-function memory context of the function we are compiling. That
248  * means a palloc() will allocate storage with the same lifetime as
249  * the function itself.
250  *
251  * Because palloc()'d storage will not be immediately freed, temporary
252  * allocations should either be performed in a short-lived memory
253  * context or explicitly pfree'd. Since not all backend functions are
254  * careful about pfree'ing their allocations, it is also wise to
255  * switch into a short-term context before calling into the
256  * backend. An appropriate context for performing short-term
257  * allocations is the plpgsql_compile_tmp_cxt.
258  *
259  * NB: this code is not re-entrant. We assume that nothing we do here could
260  * result in the invocation of another plpgsql function.
261  */
262 static PLpgSQL_function *
263 do_compile(FunctionCallInfo fcinfo,
264  HeapTuple procTup,
265  PLpgSQL_function *function,
266  PLpgSQL_func_hashkey *hashkey,
267  bool forValidator)
268 {
269  Form_pg_proc procStruct = (Form_pg_proc) GETSTRUCT(procTup);
270  bool is_dml_trigger = CALLED_AS_TRIGGER(fcinfo);
271  bool is_event_trigger = CALLED_AS_EVENT_TRIGGER(fcinfo);
272  Datum prosrcdatum;
273  bool isnull;
274  char *proc_source;
275  HeapTuple typeTup;
276  Form_pg_type typeStruct;
277  PLpgSQL_variable *var;
278  PLpgSQL_rec *rec;
279  int i;
280  ErrorContextCallback plerrcontext;
281  int parse_rc;
282  Oid rettypeid;
283  int numargs;
284  int num_in_args = 0;
285  int num_out_args = 0;
286  Oid *argtypes;
287  char **argnames;
288  char *argmodes;
289  int *in_arg_varnos = NULL;
290  PLpgSQL_variable **out_arg_variables;
291  MemoryContext func_cxt;
292 
293  /*
294  * Setup the scanner input and error info. We assume that this function
295  * cannot be invoked recursively, so there's no need to save and restore
296  * the static variables used here.
297  */
298  prosrcdatum = SysCacheGetAttr(PROCOID, procTup,
299  Anum_pg_proc_prosrc, &isnull);
300  if (isnull)
301  elog(ERROR, "null prosrc");
302  proc_source = TextDatumGetCString(prosrcdatum);
303  plpgsql_scanner_init(proc_source);
304 
305  plpgsql_error_funcname = pstrdup(NameStr(procStruct->proname));
306 
307  /*
308  * Setup error traceback support for ereport()
309  */
310  plerrcontext.callback = plpgsql_compile_error_callback;
311  plerrcontext.arg = forValidator ? proc_source : NULL;
312  plerrcontext.previous = error_context_stack;
313  error_context_stack = &plerrcontext;
314 
315  /*
316  * Do extra syntax checks when validating the function definition. We skip
317  * this when actually compiling functions for execution, for performance
318  * reasons.
319  */
320  plpgsql_check_syntax = forValidator;
321 
322  /*
323  * Create the new function struct, if not done already. The function
324  * structs are never thrown away, so keep them in TopMemoryContext.
325  */
326  if (function == NULL)
327  {
328  function = (PLpgSQL_function *)
329  MemoryContextAllocZero(TopMemoryContext, sizeof(PLpgSQL_function));
330  }
331  else
332  {
333  /* re-using a previously existing struct, so clear it out */
334  memset(function, 0, sizeof(PLpgSQL_function));
335  }
336  plpgsql_curr_compile = function;
337 
338  /*
339  * All the permanent output of compilation (e.g. parse tree) is kept in a
340  * per-function memory context, so it can be reclaimed easily.
341  */
342  func_cxt = AllocSetContextCreate(TopMemoryContext,
343  "PL/pgSQL function",
344  ALLOCSET_DEFAULT_SIZES);
345  plpgsql_compile_tmp_cxt = MemoryContextSwitchTo(func_cxt);
346 
347  function->fn_signature = format_procedure(fcinfo->flinfo->fn_oid);
348  MemoryContextSetIdentifier(func_cxt, function->fn_signature);
349  function->fn_oid = fcinfo->flinfo->fn_oid;
350  function->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
351  function->fn_tid = procTup->t_self;
352  function->fn_input_collation = fcinfo->fncollation;
353  function->fn_cxt = func_cxt;
354  function->out_param_varno = -1; /* set up for no OUT param */
355  function->resolve_option = plpgsql_variable_conflict;
356  function->print_strict_params = plpgsql_print_strict_params;
357  /* only promote extra warnings and errors at CREATE FUNCTION time */
358  function->extra_warnings = forValidator ? plpgsql_extra_warnings : 0;
359  function->extra_errors = forValidator ? plpgsql_extra_errors : 0;
360 
361  if (is_dml_trigger)
362  function->fn_is_trigger = PLPGSQL_DML_TRIGGER;
363  else if (is_event_trigger)
364  function->fn_is_trigger = PLPGSQL_EVENT_TRIGGER;
365  else
366  function->fn_is_trigger = PLPGSQL_NOT_TRIGGER;
367 
368  function->fn_prokind = procStruct->prokind;
369 
370  function->nstatements = 0;
371 
372  /*
373  * Initialize the compiler, particularly the namespace stack. The
374  * outermost namespace contains function parameters and other special
375  * variables (such as FOUND), and is named after the function itself.
376  */
377  plpgsql_ns_init();
378  plpgsql_ns_push(NameStr(procStruct->proname), PLPGSQL_LABEL_BLOCK);
379  plpgsql_DumpExecTree = false;
380  plpgsql_start_datums();
381 
382  switch (function->fn_is_trigger)
383  {
384  case PLPGSQL_NOT_TRIGGER:
385 
386  /*
387  * Fetch info about the procedure's parameters. Allocations aren't
388  * needed permanently, so make them in tmp cxt.
389  *
390  * We also need to resolve any polymorphic input or output
391  * argument types. In validation mode we won't be able to, so we
392  * arbitrarily assume we are dealing with integers.
393  */
394  MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
395 
396  numargs = get_func_arg_info(procTup,
397  &argtypes, &argnames, &argmodes);
398 
399  plpgsql_resolve_polymorphic_argtypes(numargs, argtypes, argmodes,
400  fcinfo->flinfo->fn_expr,
401  forValidator,
402  plpgsql_error_funcname);
403 
404  in_arg_varnos = (int *) palloc(numargs * sizeof(int));
405  out_arg_variables = (PLpgSQL_variable **) palloc(numargs * sizeof(PLpgSQL_variable *));
406 
407  MemoryContextSwitchTo(func_cxt);
408 
409  /*
410  * Create the variables for the procedure's parameters.
411  */
412  for (i = 0; i < numargs; i++)
413  {
414  char buf[32];
415  Oid argtypeid = argtypes[i];
416  char argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
417  PLpgSQL_type *argdtype;
418  PLpgSQL_variable *argvariable;
419  PLpgSQL_nsitem_type argitemtype;
420 
421  /* Create $n name for variable */
422  snprintf(buf, sizeof(buf), "$%d", i + 1);
423 
424  /* Create datatype info */
425  argdtype = plpgsql_build_datatype(argtypeid,
426  -1,
427  function->fn_input_collation,
428  NULL);
429 
430  /* Disallow pseudotype argument */
431  /* (note we already replaced polymorphic types) */
432  /* (build_variable would do this, but wrong message) */
433  if (argdtype->ttype == PLPGSQL_TTYPE_PSEUDO)
434  ereport(ERROR,
435  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
436  errmsg("PL/pgSQL functions cannot accept type %s",
437  format_type_be(argtypeid))));
438 
439  /*
440  * Build variable and add to datum list. If there's a name
441  * for the argument, use that as refname, else use $n name.
442  */
443  argvariable = plpgsql_build_variable((argnames &&
444  argnames[i][0] != '\0') ?
445  argnames[i] : buf,
446  0, argdtype, false);
447 
448  if (argvariable->dtype == PLPGSQL_DTYPE_VAR)
449  {
450  argitemtype = PLPGSQL_NSTYPE_VAR;
451  }
452  else
453  {
454  Assert(argvariable->dtype == PLPGSQL_DTYPE_REC);
455  argitemtype = PLPGSQL_NSTYPE_REC;
456  }
457 
458  /* Remember arguments in appropriate arrays */
459  if (argmode == PROARGMODE_IN ||
460  argmode == PROARGMODE_INOUT ||
461  argmode == PROARGMODE_VARIADIC)
462  in_arg_varnos[num_in_args++] = argvariable->dno;
463  if (argmode == PROARGMODE_OUT ||
464  argmode == PROARGMODE_INOUT ||
465  argmode == PROARGMODE_TABLE)
466  out_arg_variables[num_out_args++] = argvariable;
467 
468  /* Add to namespace under the $n name */
469  add_parameter_name(argitemtype, argvariable->dno, buf);
470 
471  /* If there's a name for the argument, make an alias */
472  if (argnames && argnames[i][0] != '\0')
473  add_parameter_name(argitemtype, argvariable->dno,
474  argnames[i]);
475  }
476 
477  /*
478  * If there's just one OUT parameter, out_param_varno points
479  * directly to it. If there's more than one, build a row that
480  * holds all of them. Procedures return a row even for one OUT
481  * parameter.
482  */
483  if (num_out_args > 1 ||
484  (num_out_args == 1 && function->fn_prokind == PROKIND_PROCEDURE))
485  {
486  PLpgSQL_row *row = build_row_from_vars(out_arg_variables,
487  num_out_args);
488 
489  plpgsql_adddatum((PLpgSQL_datum *) row);
490  function->out_param_varno = row->dno;
491  }
492  else if (num_out_args == 1)
493  function->out_param_varno = out_arg_variables[0]->dno;
494 
495  /*
496  * Check for a polymorphic returntype. If found, use the actual
497  * returntype type from the caller's FuncExpr node, if we have
498  * one. (In validation mode we arbitrarily assume we are dealing
499  * with integers.)
500  *
501  * Note: errcode is FEATURE_NOT_SUPPORTED because it should always
502  * work; if it doesn't we're in some context that fails to make
503  * the info available.
504  */
505  rettypeid = procStruct->prorettype;
506  if (IsPolymorphicType(rettypeid))
507  {
508  if (forValidator)
509  {
510  if (rettypeid == ANYARRAYOID)
511  rettypeid = INT4ARRAYOID;
512  else if (rettypeid == ANYRANGEOID)
513  rettypeid = INT4RANGEOID;
514  else /* ANYELEMENT or ANYNONARRAY */
515  rettypeid = INT4OID;
516  /* XXX what could we use for ANYENUM? */
517  }
518  else
519  {
520  rettypeid = get_fn_expr_rettype(fcinfo->flinfo);
521  if (!OidIsValid(rettypeid))
522  ereport(ERROR,
523  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
524  errmsg("could not determine actual return type "
525  "for polymorphic function \"%s\"",
526  plpgsql_error_funcname)));
527  }
528  }
529 
530  /*
531  * Normal function has a defined returntype
532  */
533  function->fn_rettype = rettypeid;
534  function->fn_retset = procStruct->proretset;
535 
536  /*
537  * Lookup the function's return type
538  */
539  typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(rettypeid));
540  if (!HeapTupleIsValid(typeTup))
541  elog(ERROR, "cache lookup failed for type %u", rettypeid);
542  typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
543 
544  /* Disallow pseudotype result, except VOID or RECORD */
545  /* (note we already replaced polymorphic types) */
546  if (typeStruct->typtype == TYPTYPE_PSEUDO)
547  {
548  if (rettypeid == VOIDOID ||
549  rettypeid == RECORDOID)
550  /* okay */ ;
551  else if (rettypeid == TRIGGEROID || rettypeid == EVTTRIGGEROID)
552  ereport(ERROR,
553  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
554  errmsg("trigger functions can only be called as triggers")));
555  else
556  ereport(ERROR,
557  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
558  errmsg("PL/pgSQL functions cannot return type %s",
559  format_type_be(rettypeid))));
560  }
561 
562  function->fn_retistuple = type_is_rowtype(rettypeid);
563  function->fn_retisdomain = (typeStruct->typtype == TYPTYPE_DOMAIN);
564  function->fn_retbyval = typeStruct->typbyval;
565  function->fn_rettyplen = typeStruct->typlen;
566 
567  /*
568  * install $0 reference, but only for polymorphic return types,
569  * and not when the return is specified through an output
570  * parameter.
571  */
572  if (IsPolymorphicType(procStruct->prorettype) &&
573  num_out_args == 0)
574  {
575  (void) plpgsql_build_variable("$0", 0,
576  build_datatype(typeTup,
577  -1,
578  function->fn_input_collation,
579  NULL),
580  true);
581  }
582 
583  ReleaseSysCache(typeTup);
584  break;
585 
586  case PLPGSQL_DML_TRIGGER:
587  /* Trigger procedure's return type is unknown yet */
588  function->fn_rettype = InvalidOid;
589  function->fn_retbyval = false;
590  function->fn_retistuple = true;
591  function->fn_retisdomain = false;
592  function->fn_retset = false;
593 
594  /* shouldn't be any declared arguments */
595  if (procStruct->pronargs != 0)
596  ereport(ERROR,
597  (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
598  errmsg("trigger functions cannot have declared arguments"),
599  errhint("The arguments of the trigger can be accessed through TG_NARGS and TG_ARGV instead.")));
600 
601  /* Add the record for referencing NEW ROW */
602  rec = plpgsql_build_record("new", 0, NULL, RECORDOID, true);
603  function->new_varno = rec->dno;
604 
605  /* Add the record for referencing OLD ROW */
606  rec = plpgsql_build_record("old", 0, NULL, RECORDOID, true);
607  function->old_varno = rec->dno;
608 
609  /* Add the variable tg_name */
610  var = plpgsql_build_variable("tg_name", 0,
611  plpgsql_build_datatype(NAMEOID,
612  -1,
613  function->fn_input_collation,
614  NULL),
615  true);
616  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
617  var->dtype = PLPGSQL_DTYPE_PROMISE;
618  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_NAME;
619 
620  /* Add the variable tg_when */
621  var = plpgsql_build_variable("tg_when", 0,
622  plpgsql_build_datatype(TEXTOID,
623  -1,
624  function->fn_input_collation,
625  NULL),
626  true);
627  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
628  var->dtype = PLPGSQL_DTYPE_PROMISE;
629  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_WHEN;
630 
631  /* Add the variable tg_level */
632  var = plpgsql_build_variable("tg_level", 0,
633  plpgsql_build_datatype(TEXTOID,
634  -1,
635  function->fn_input_collation,
636  NULL),
637  true);
638  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
639  var->dtype = PLPGSQL_DTYPE_PROMISE;
640  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_LEVEL;
641 
642  /* Add the variable tg_op */
643  var = plpgsql_build_variable("tg_op", 0,
644  plpgsql_build_datatype(TEXTOID,
645  -1,
646  function->fn_input_collation,
647  NULL),
648  true);
649  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
650  var->dtype = PLPGSQL_DTYPE_PROMISE;
651  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_OP;
652 
653  /* Add the variable tg_relid */
654  var = plpgsql_build_variable("tg_relid", 0,
655  plpgsql_build_datatype(OIDOID,
656  -1,
657  InvalidOid,
658  NULL),
659  true);
660  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
661  var->dtype = PLPGSQL_DTYPE_PROMISE;
662  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_RELID;
663 
664  /* Add the variable tg_relname */
665  var = plpgsql_build_variable("tg_relname", 0,
666  plpgsql_build_datatype(NAMEOID,
667  -1,
668  function->fn_input_collation,
669  NULL),
670  true);
671  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
672  var->dtype = PLPGSQL_DTYPE_PROMISE;
673  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TABLE_NAME;
674 
675  /* tg_table_name is now preferred to tg_relname */
676  var = plpgsql_build_variable("tg_table_name", 0,
677  plpgsql_build_datatype(NAMEOID,
678  -1,
679  function->fn_input_collation,
680  NULL),
681  true);
682  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
683  var->dtype = PLPGSQL_DTYPE_PROMISE;
684  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TABLE_NAME;
685 
686  /* add the variable tg_table_schema */
687  var = plpgsql_build_variable("tg_table_schema", 0,
688  plpgsql_build_datatype(NAMEOID,
689  -1,
690  function->fn_input_collation,
691  NULL),
692  true);
693  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
694  var->dtype = PLPGSQL_DTYPE_PROMISE;
695  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TABLE_SCHEMA;
696 
697  /* Add the variable tg_nargs */
698  var = plpgsql_build_variable("tg_nargs", 0,
699  plpgsql_build_datatype(INT4OID,
700  -1,
701  InvalidOid,
702  NULL),
703  true);
704  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
705  var->dtype = PLPGSQL_DTYPE_PROMISE;
706  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_NARGS;
707 
708  /* Add the variable tg_argv */
709  var = plpgsql_build_variable("tg_argv", 0,
710  plpgsql_build_datatype(TEXTARRAYOID,
711  -1,
712  function->fn_input_collation,
713  NULL),
714  true);
715  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
716  var->dtype = PLPGSQL_DTYPE_PROMISE;
717  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_ARGV;
718 
719  break;
720 
721  case PLPGSQL_EVENT_TRIGGER:
722  function->fn_rettype = VOIDOID;
723  function->fn_retbyval = false;
724  function->fn_retistuple = true;
725  function->fn_retisdomain = false;
726  function->fn_retset = false;
727 
728  /* shouldn't be any declared arguments */
729  if (procStruct->pronargs != 0)
730  ereport(ERROR,
731  (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
732  errmsg("event trigger functions cannot have declared arguments")));
733 
734  /* Add the variable tg_event */
735  var = plpgsql_build_variable("tg_event", 0,
736  plpgsql_build_datatype(TEXTOID,
737  -1,
738  function->fn_input_collation,
739  NULL),
740  true);
741  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
742  var->dtype = PLPGSQL_DTYPE_PROMISE;
743  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_EVENT;
744 
745  /* Add the variable tg_tag */
746  var = plpgsql_build_variable("tg_tag", 0,
747  plpgsql_build_datatype(TEXTOID,
748  -1,
749  function->fn_input_collation,
750  NULL),
751  true);
752  Assert(var->dtype == PLPGSQL_DTYPE_VAR);
753  var->dtype = PLPGSQL_DTYPE_PROMISE;
754  ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TAG;
755 
756  break;
757 
758  default:
759  elog(ERROR, "unrecognized function typecode: %d",
760  (int) function->fn_is_trigger);
761  break;
762  }
763 
764  /* Remember if function is STABLE/IMMUTABLE */
765  function->fn_readonly = (procStruct->provolatile != PROVOLATILE_VOLATILE);
766 
767  /*
768  * Create the magic FOUND variable.
769  */
770  var = plpgsql_build_variable("found", 0,
771  plpgsql_build_datatype(BOOLOID,
772  -1,
773  InvalidOid,
774  NULL),
775  true);
776  function->found_varno = var->dno;
777 
778  /*
779  * Now parse the function's text
780  */
781  parse_rc = plpgsql_yyparse();
782  if (parse_rc != 0)
783  elog(ERROR, "plpgsql parser returned %d", parse_rc);
784  function->action = plpgsql_parse_result;
785 
786  plpgsql_scanner_finish();
787  pfree(proc_source);
788 
789  /*
790  * If it has OUT parameters or returns VOID or returns a set, we allow
791  * control to fall off the end without an explicit RETURN statement. The
792  * easiest way to implement this is to add a RETURN statement to the end
793  * of the statement list during parsing.
794  */
795  if (num_out_args > 0 || function->fn_rettype == VOIDOID ||
796  function->fn_retset)
797  add_dummy_return(function);
798 
799  /*
800  * Complete the function's info
801  */
802  function->fn_nargs = procStruct->pronargs;
803  for (i = 0; i < function->fn_nargs; i++)
804  function->fn_argvarnos[i] = in_arg_varnos[i];
805 
806  plpgsql_finish_datums(function);
807 
808  /* Debug dump for completed functions */
809  if (plpgsql_DumpExecTree)
810  plpgsql_dumptree(function);
811 
812  /*
813  * add it to the hash table
814  */
815  plpgsql_HashTableInsert(function, hashkey);
816 
817  /*
818  * Pop the error context stack
819  */
820  error_context_stack = plerrcontext.previous;
821  plpgsql_error_funcname = NULL;
822 
823  plpgsql_check_syntax = false;
824 
825  MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
826  plpgsql_compile_tmp_cxt = NULL;
827  return function;
828 }
829 
830 /* ----------
831  * plpgsql_compile_inline Make an execution tree for an anonymous code block.
832  *
833  * Note: this is generally parallel to do_compile(); is it worth trying to
834  * merge the two?
835  *
836  * Note: we assume the block will be thrown away so there is no need to build
837  * persistent data structures.
838  * ----------
839  */
840 PLpgSQL_function *
841 plpgsql_compile_inline(char *proc_source)
842 {
843  char *func_name = "inline_code_block";
844  PLpgSQL_function *function;
845  ErrorContextCallback plerrcontext;
846  PLpgSQL_variable *var;
847  int parse_rc;
848  MemoryContext func_cxt;
849 
850  /*
851  * Setup the scanner input and error info. We assume that this function
852  * cannot be invoked recursively, so there's no need to save and restore
853  * the static variables used here.
854  */
855  plpgsql_scanner_init(proc_source);
856 
857  plpgsql_error_funcname = func_name;
858 
859  /*
860  * Setup error traceback support for ereport()
861  */
862  plerrcontext.callback = plpgsql_compile_error_callback;
863  plerrcontext.arg = proc_source;
864  plerrcontext.previous = error_context_stack;
865  error_context_stack = &plerrcontext;
866 
867  /* Do extra syntax checking if check_function_bodies is on */
868  plpgsql_check_syntax = check_function_bodies;
869 
870  /* Function struct does not live past current statement */
871  function = (PLpgSQL_function *) palloc0(sizeof(PLpgSQL_function));
872 
873  plpgsql_curr_compile = function;
874 
875  /*
876  * All the rest of the compile-time storage (e.g. parse tree) is kept in
877  * its own memory context, so it can be reclaimed easily.
878  */
879  func_cxt = AllocSetContextCreate(CurrentMemoryContext,
880  "PL/pgSQL inline code context",
881  ALLOCSET_DEFAULT_SIZES);
882  plpgsql_compile_tmp_cxt = MemoryContextSwitchTo(func_cxt);
883 
884  function->fn_signature = pstrdup(func_name);
885  function->fn_is_trigger = PLPGSQL_NOT_TRIGGER;
886  function->fn_input_collation = InvalidOid;
887  function->fn_cxt = func_cxt;
888  function->out_param_varno = -1; /* set up for no OUT param */
889  function->resolve_option = plpgsql_variable_conflict;
890  function->print_strict_params = plpgsql_print_strict_params;
891 
892  /*
893  * don't do extra validation for inline code as we don't want to add spam
894  * at runtime
895  */
896  function->extra_warnings = 0;
897  function->extra_errors = 0;
898 
899  function->nstatements = 0;
900 
901  plpgsql_ns_init();
902  plpgsql_ns_push(func_name, PLPGSQL_LABEL_BLOCK);
903  plpgsql_DumpExecTree = false;
904  plpgsql_start_datums();
905 
906  /* Set up as though in a function returning VOID */
907  function->fn_rettype = VOIDOID;
908  function->fn_retset = false;
909  function->fn_retistuple = false;
910  function->fn_retisdomain = false;
911  function->fn_prokind = PROKIND_FUNCTION;
912  /* a bit of hardwired knowledge about type VOID here */
913  function->fn_retbyval = true;
914  function->fn_rettyplen = sizeof(int32);
915 
916  /*
917  * Remember if function is STABLE/IMMUTABLE. XXX would it be better to
918  * set this true inside a read-only transaction? Not clear.
919  */
920  function->fn_readonly = false;
921 
922  /*
923  * Create the magic FOUND variable.
924  */
925  var = plpgsql_build_variable("found", 0,
926  plpgsql_build_datatype(BOOLOID,
927  -1,
928  InvalidOid,
929  NULL),
930  true);
931  function->found_varno = var->dno;
932 
933  /*
934  * Now parse the function's text
935  */
936  parse_rc = plpgsql_yyparse();
937  if (parse_rc != 0)
938  elog(ERROR, "plpgsql parser returned %d", parse_rc);
939  function->action = plpgsql_parse_result;
940 
941  plpgsql_scanner_finish();
942 
943  /*
944  * If it returns VOID (always true at the moment), we allow control to
945  * fall off the end without an explicit RETURN statement.
946  */
947  if (function->fn_rettype == VOIDOID)
948  add_dummy_return(function);
949 
950  /*
951  * Complete the function's info
952  */
953  function->fn_nargs = 0;
954 
955  plpgsql_finish_datums(function);
956 
957  /*
958  * Pop the error context stack
959  */
960  error_context_stack = plerrcontext.previous;
961  plpgsql_error_funcname = NULL;
962 
963  plpgsql_check_syntax = false;
964 
965  MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
966  plpgsql_compile_tmp_cxt = NULL;
967  return function;
968 }
969 
970 
971 /*
972  * error context callback to let us supply a call-stack traceback.
973  * If we are validating or executing an anonymous code block, the function
974  * source text is passed as an argument.
975  */
976 static void
977 plpgsql_compile_error_callback(void *arg)
978 {
979  if (arg)
980  {
981  /*
982  * Try to convert syntax error position to reference text of original
983  * CREATE FUNCTION or DO command.
984  */
985  if (function_parse_error_transpose((const char *) arg))
986  return;
987 
988  /*
989  * Done if a syntax error position was reported; otherwise we have to
990  * fall back to a "near line N" report.
991  */
992  }
993 
994  if (plpgsql_error_funcname)
995  errcontext("compilation of PL/pgSQL function \"%s\" near line %d",
996  plpgsql_error_funcname, plpgsql_latest_lineno());
997 }
998 
999 
1000 /*
1001  * Add a name for a function parameter to the function's namespace
1002  */
1003 static void
1004 add_parameter_name(PLpgSQL_nsitem_type itemtype, int itemno, const char *name)
1005 {
1006  /*
1007  * Before adding the name, check for duplicates. We need this even though
1008  * functioncmds.c has a similar check, because that code explicitly
1009  * doesn't complain about conflicting IN and OUT parameter names. In
1010  * plpgsql, such names are in the same namespace, so there is no way to
1011  * disambiguate.
1012  */
1013  if (plpgsql_ns_lookup(plpgsql_ns_top(), true,
1014  name, NULL, NULL,
1015  NULL) != NULL)
1016  ereport(ERROR,
1017  (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
1018  errmsg("parameter name \"%s\" used more than once",
1019  name)));
1020 
1021  /* OK, add the name */
1022  plpgsql_ns_additem(itemtype, itemno, name);
1023 }
1024 
1025 /*
1026  * Add a dummy RETURN statement to the given function's body
1027  */
1028 static void
1029 add_dummy_return(PLpgSQL_function *function)
1030 {
1031  /*
1032  * If the outer block has an EXCEPTION clause, we need to make a new outer
1033  * block, since the added RETURN shouldn't act like it is inside the
1034  * EXCEPTION clause.
1035  */
1036  if (function->action->exceptions != NULL)
1037  {
1038  PLpgSQL_stmt_block *new;
1039 
1040  new = palloc0(sizeof(PLpgSQL_stmt_block));
1041  new->cmd_type = PLPGSQL_STMT_BLOCK;
1042  new->stmtid = ++function->nstatements;
1043  new->body = list_make1(function->action);
1044 
1045  function->action = new;
1046  }
1047  if (function->action->body == NIL ||
1048  ((PLpgSQL_stmt *) llast(function->action->body))->cmd_type != PLPGSQL_STMT_RETURN)
1049  {
1050  PLpgSQL_stmt_return *new;
1051 
1052  new = palloc0(sizeof(PLpgSQL_stmt_return));
1053  new->cmd_type = PLPGSQL_STMT_RETURN;
1054  new->stmtid = ++function->nstatements;
1055  new->expr = NULL;
1056  new->retvarno = function->out_param_varno;
1057 
1058  function->action->body = lappend(function->action->body, new);
1059  }
1060 }
1061 
1062 
1063 /*
1064  * plpgsql_parser_setup set up parser hooks for dynamic parameters
1065  *
1066  * Note: this routine, and the hook functions it prepares for, are logically
1067  * part of plpgsql parsing. But they actually run during function execution,
1068  * when we are ready to evaluate a SQL query or expression that has not
1069  * previously been parsed and planned.
1070  */
1071 void
1072 plpgsql_parser_setup(struct ParseState *pstate, PLpgSQL_expr *expr)
1073 {
1074  pstate->p_pre_columnref_hook = plpgsql_pre_column_ref;
1075  pstate->p_post_columnref_hook = plpgsql_post_column_ref;
1076  pstate->p_paramref_hook = plpgsql_param_ref;
1077  /* no need to use p_coerce_param_hook */
1078  pstate->p_ref_hook_state = (void *) expr;
1079 }
1080 
1081 /*
1082  * plpgsql_pre_column_ref parser callback before parsing a ColumnRef
1083  */
1084 static Node *
1085 plpgsql_pre_column_ref(ParseState *pstate, ColumnRef *cref)
1086 {
1087  PLpgSQL_expr *expr = (PLpgSQL_expr *) pstate->p_ref_hook_state;
1088 
1089  if (expr->func->resolve_option == PLPGSQL_RESOLVE_VARIABLE)
1090  return resolve_column_ref(pstate, expr, cref, false);
1091  else
1092  return NULL;
1093 }
1094 
1095 /*
1096  * plpgsql_post_column_ref parser callback after parsing a ColumnRef
1097  */
1098 static Node *
1099 plpgsql_post_column_ref(ParseState *pstate, ColumnRef *cref, Node *var)
1100 {
1101  PLpgSQL_expr *expr = (PLpgSQL_expr *) pstate->p_ref_hook_state;
1102  Node *myvar;
1103 
1104  if (expr->func->resolve_option == PLPGSQL_RESOLVE_VARIABLE)
1105  return NULL; /* we already found there's no match */
1106 
1107  if (expr->func->resolve_option == PLPGSQL_RESOLVE_COLUMN && var != NULL)
1108  return NULL; /* there's a table column, prefer that */
1109 
1110  /*
1111  * If we find a record/row variable but can't match a field name, throw
1112  * error if there was no core resolution for the ColumnRef either. In
1113  * that situation, the reference is inevitably going to fail, and
1114  * complaining about the record/row variable is likely to be more on-point
1115  * than the core parser's error message. (It's too bad we don't have
1116  * access to transformColumnRef's internal crerr state here, as in case of
1117  * a conflict with a table name this could still be less than the most
1118  * helpful error message possible.)
1119  */
1120  myvar = resolve_column_ref(pstate, expr, cref, (var == NULL));
1121 
1122  if (myvar != NULL && var != NULL)
1123  {
1124  /*
1125  * We could leave it to the core parser to throw this error, but we
1126  * can add a more useful detail message than the core could.
1127  */
1128  ereport(ERROR,
1129  (errcode(ERRCODE_AMBIGUOUS_COLUMN),
1130  errmsg("column reference \"%s\" is ambiguous",
1131  NameListToString(cref->fields)),
1132  errdetail("It could refer to either a PL/pgSQL variable or a table column."),
1133  parser_errposition(pstate, cref->location)));
1134  }
1135 
1136  return myvar;
1137 }
1138 
1139 /*
1140  * plpgsql_param_ref parser callback for ParamRefs ($n symbols)
1141  */
1142 static Node *
1143 plpgsql_param_ref(ParseState *pstate, ParamRef *pref)
1144 {
1145  PLpgSQL_expr *expr = (PLpgSQL_expr *) pstate->p_ref_hook_state;
1146  char pname[32];
1147  PLpgSQL_nsitem *nse;
1148 
1149  snprintf(pname, sizeof(pname), "$%d", pref->number);
1150 
1151  nse = plpgsql_ns_lookup(expr->ns, false,
1152  pname, NULL, NULL,
1153  NULL);
1154 
1155  if (nse == NULL)
1156  return NULL; /* name not known to plpgsql */
1157 
1158  return make_datum_param(expr, nse->itemno, pref->location);
1159 }
1160 
1161 /*
1162  * resolve_column_ref attempt to resolve a ColumnRef as a plpgsql var
1163  *
1164  * Returns the translated node structure, or NULL if name not found
1165  *
1166  * error_if_no_field tells whether to throw error or quietly return NULL if
1167  * we are able to match a record/row name but don't find a field name match.
1168  */
1169 static Node *
1170 resolve_column_ref(ParseState *pstate, PLpgSQL_expr *expr,
1171  ColumnRef *cref, bool error_if_no_field)
1172 {
1173  PLpgSQL_execstate *estate;
1174  PLpgSQL_nsitem *nse;
1175  const char *name1;
1176  const char *name2 = NULL;
1177  const char *name3 = NULL;
1178  const char *colname = NULL;
1179  int nnames;
1180  int nnames_scalar = 0;
1181  int nnames_wholerow = 0;
1182  int nnames_field = 0;
1183 
1184  /*
1185  * We use the function's current estate to resolve parameter data types.
1186  * This is really pretty bogus because there is no provision for updating
1187  * plans when those types change ...
1188  */
1189  estate = expr->func->cur_estate;
1190 
1191  /*----------
1192  * The allowed syntaxes are:
1193  *
1194  * A Scalar variable reference, or whole-row record reference.
1195  * A.B Qualified scalar or whole-row reference, or field reference.
1196  * A.B.C Qualified record field reference.
1197  * A.* Whole-row record reference.
1198  * A.B.* Qualified whole-row record reference.
1199  *----------
1200  */
1201  switch (list_length(cref->fields))
1202  {
1203  case 1:
1204  {
1205  Node *field1 = (Node *) linitial(cref->fields);
1206 
1207  Assert(IsA(field1, String));
1208  name1 = strVal(field1);
1209  nnames_scalar = 1;
1210  nnames_wholerow = 1;
1211  break;
1212  }
1213  case 2:
1214  {
1215  Node *field1 = (Node *) linitial(cref->fields);
1216  Node *field2 = (Node *) lsecond(cref->fields);
1217 
1218  Assert(IsA(field1, String));
1219  name1 = strVal(field1);
1220 
1221  /* Whole-row reference? */
1222  if (IsA(field2, A_Star))
1223  {
1224  /* Set name2 to prevent matches to scalar variables */
1225  name2 = "*";
1226  nnames_wholerow = 1;
1227  break;
1228  }
1229 
1230  Assert(IsA(field2, String));
1231  name2 = strVal(field2);
1232  colname = name2;
1233  nnames_scalar = 2;
1234  nnames_wholerow = 2;
1235  nnames_field = 1;
1236  break;
1237  }
1238  case 3:
1239  {
1240  Node *field1 = (Node *) linitial(cref->fields);
1241  Node *field2 = (Node *) lsecond(cref->fields);
1242  Node *field3 = (Node *) lthird(cref->fields);
1243 
1244  Assert(IsA(field1, String));
1245  name1 = strVal(field1);
1246  Assert(IsA(field2, String));
1247  name2 = strVal(field2);
1248 
1249  /* Whole-row reference? */
1250  if (IsA(field3, A_Star))
1251  {
1252  /* Set name3 to prevent matches to scalar variables */
1253  name3 = "*";
1254  nnames_wholerow = 2;
1255  break;
1256  }
1257 
1258  Assert(IsA(field3, String));
1259  name3 = strVal(field3);
1260  colname = name3;
1261  nnames_field = 2;
1262  break;
1263  }
1264  default:
1265  /* too many names, ignore */
1266  return NULL;
1267  }
1268 
1269  nse = plpgsql_ns_lookup(expr->ns, false,
1270  name1, name2, name3,
1271  &nnames);
1272 
1273  if (nse == NULL)
1274  return NULL; /* name not known to plpgsql */
1275 
1276  switch (nse->itemtype)
1277  {
1278  case PLPGSQL_NSTYPE_VAR:
1279  if (nnames == nnames_scalar)
1280  return make_datum_param(expr, nse->itemno, cref->location);
1281  break;
1282  case PLPGSQL_NSTYPE_REC:
1283  if (nnames == nnames_wholerow)
1284  return make_datum_param(expr, nse->itemno, cref->location);
1285  if (nnames == nnames_field)
1286  {
1287  /* colname could be a field in this record */
1288  PLpgSQL_rec *rec = (PLpgSQL_rec *) estate->datums[nse->itemno];
1289  int i;
1290 
1291  /* search for a datum referencing this field */
1292  i = rec->firstfield;
1293  while (i >= 0)
1294  {
1295  PLpgSQL_recfield *fld = (PLpgSQL_recfield *) estate->datums[i];
1296 
1297  Assert(fld->dtype == PLPGSQL_DTYPE_RECFIELD &&
1298  fld->recparentno == nse->itemno);
1299  if (strcmp(fld->fieldname, colname) == 0)
1300  {
1301  return make_datum_param(expr, i, cref->location);
1302  }
1303  i = fld->nextfield;
1304  }
1305 
1306  /*
1307  * We should not get here, because a RECFIELD datum should
1308  * have been built at parse time for every possible qualified
1309  * reference to fields of this record. But if we do, handle
1310  * it like field-not-found: throw error or return NULL.
1311  */
1312  if (error_if_no_field)
1313  ereport(ERROR,
1314  (errcode(ERRCODE_UNDEFINED_COLUMN),
1315  errmsg("record \"%s\" has no field \"%s\"",
1316  (nnames_field == 1) ? name1 : name2,
1317  colname),
1318  parser_errposition(pstate, cref->location)));
1319  }
1320  break;
1321  default:
1322  elog(ERROR, "unrecognized plpgsql itemtype: %d", nse->itemtype);
1323  }
1324 
1325  /* Name format doesn't match the plpgsql variable type */
1326  return NULL;
1327 }
1328 
1329 /*
1330  * Helper for columnref parsing: build a Param referencing a plpgsql datum,
1331  * and make sure that that datum is listed in the expression's paramnos.
1332  */
1333 static Node *
1334 make_datum_param(PLpgSQL_expr *expr, int dno, int location)
1335 {
1336  PLpgSQL_execstate *estate;
1337  PLpgSQL_datum *datum;
1338  Param *param;
1339  MemoryContext oldcontext;
1340 
1341  /* see comment in resolve_column_ref */
1342  estate = expr->func->cur_estate;
1343  Assert(dno >= 0 && dno < estate->ndatums);
1344  datum = estate->datums[dno];
1345 
1346  /*
1347  * Bitmapset must be allocated in function's permanent memory context
1348  */
1349  oldcontext = MemoryContextSwitchTo(expr->func->fn_cxt);
1350  expr->paramnos = bms_add_member(expr->paramnos, dno);
1351  MemoryContextSwitchTo(oldcontext);
1352 
1353  param = makeNode(Param);
1354  param->paramkind = PARAM_EXTERN;
1355  param->paramid = dno + 1;
1356  plpgsql_exec_get_datum_type_info(estate,
1357  datum,
1358  &param->paramtype,
1359  &param->paramtypmod,
1360  &param->paramcollid);
1361  param->location = location;
1362 
1363  return (Node *) param;
1364 }
1365 
1366 
1367 /* ----------
1368  * plpgsql_parse_word The scanner calls this to postparse
1369  * any single word that is not a reserved keyword.
1370  *
1371  * word1 is the downcased/dequoted identifier; it must be palloc'd in the
1372  * function's long-term memory context.
1373  *
1374  * yytxt is the original token text; we need this to check for quoting,
1375  * so that later checks for unreserved keywords work properly.
1376  *
1377  * We attempt to recognize the token as a variable only if lookup is true
1378  * and the plpgsql_IdentifierLookup context permits it.
1379  *
1380  * If recognized as a variable, fill in *wdatum and return true;
1381  * if not recognized, fill in *word and return false.
1382  * (Note: those two pointers actually point to members of the same union,
1383  * but for notational reasons we pass them separately.)
1384  * ----------
1385  */
1386 bool
1387 plpgsql_parse_word(char *word1, const char *yytxt, bool lookup,
1388  PLwdatum *wdatum, PLword *word)
1389 {
1390  PLpgSQL_nsitem *ns;
1391 
1392  /*
1393  * We should not lookup variables in DECLARE sections. In SQL
1394  * expressions, there's no need to do so either --- lookup will happen
1395  * when the expression is compiled.
1396  */
1397  if (lookup && plpgsql_IdentifierLookup == IDENTIFIER_LOOKUP_NORMAL)
1398  {
1399  /*
1400  * Do a lookup in the current namespace stack
1401  */
1402  ns = plpgsql_ns_lookup(plpgsql_ns_top(), false,
1403  word1, NULL, NULL,
1404  NULL);
1405 
1406  if (ns != NULL)
1407  {
1408  switch (ns->itemtype)
1409  {
1410  case PLPGSQL_NSTYPE_VAR:
1411  case PLPGSQL_NSTYPE_REC:
1412  wdatum->datum = plpgsql_Datums[ns->itemno];
1413  wdatum->ident = word1;
1414  wdatum->quoted = (yytxt[0] == '"');
1415  wdatum->idents = NIL;
1416  return true;
1417 
1418  default:
1419  /* plpgsql_ns_lookup should never return anything else */
1420  elog(ERROR, "unrecognized plpgsql itemtype: %d",
1421  ns->itemtype);
1422  }
1423  }
1424  }
1425 
1426  /*
1427  * Nothing found - up to now it's a word without any special meaning for
1428  * us.
1429  */
1430  word->ident = word1;
1431  word->quoted = (yytxt[0] == '"');
1432  return false;
1433 }
1434 
1435 
1436 /* ----------
1437  * plpgsql_parse_dblword Same lookup for two words
1438  * separated by a dot.
1439  * ----------
1440  */
1441 bool
1442 plpgsql_parse_dblword(char *word1, char *word2,
1443  PLwdatum *wdatum, PLcword *cword)
1444 {
1445  PLpgSQL_nsitem *ns;
1446  List *idents;
1447  int nnames;
1448 
1449  idents = list_make2(makeString(word1),
1450  makeString(word2));
1451 
1452  /*
1453  * We should do nothing in DECLARE sections. In SQL expressions, we
1454  * really only need to make sure that RECFIELD datums are created when
1455  * needed.
1456  */
1457  if (plpgsql_IdentifierLookup != IDENTIFIER_LOOKUP_DECLARE)
1458  {
1459  /*
1460  * Do a lookup in the current namespace stack
1461  */
1462  ns = plpgsql_ns_lookup(plpgsql_ns_top(), false,
1463  word1, word2, NULL,
1464  &nnames);
1465  if (ns != NULL)
1466  {
1467  switch (ns->itemtype)
1468  {
1469  case PLPGSQL_NSTYPE_VAR:
1470  /* Block-qualified reference to scalar variable. */
1471  wdatum->datum = plpgsql_Datums[ns->itemno];
1472  wdatum->ident = NULL;
1473  wdatum->quoted = false; /* not used */
1474  wdatum->idents = idents;
1475  return true;
1476 
1477  case PLPGSQL_NSTYPE_REC:
1478  if (nnames == 1)
1479  {
1480  /*
1481  * First word is a record name, so second word could
1482  * be a field in this record. We build a RECFIELD
1483  * datum whether it is or not --- any error will be
1484  * detected later.
1485  */
1486  PLpgSQL_rec *rec;
1487  PLpgSQL_recfield *new;
1488 
1489  rec = (PLpgSQL_rec *) (plpgsql_Datums[ns->itemno]);
1490  new = plpgsql_build_recfield(rec, word2);
1491 
1492  wdatum->datum = (PLpgSQL_datum *) new;
1493  }
1494  else
1495  {
1496  /* Block-qualified reference to record variable. */
1497  wdatum->datum = plpgsql_Datums[ns->itemno];
1498  }
1499  wdatum->ident = NULL;
1500  wdatum->quoted = false; /* not used */
1501  wdatum->idents = idents;
1502  return true;
1503 
1504  default:
1505  break;
1506  }
1507  }
1508  }
1509 
1510  /* Nothing found */
1511  cword->idents = idents;
1512  return false;
1513 }
1514 
1515 
1516 /* ----------
1517  * plpgsql_parse_tripword Same lookup for three words
1518  * separated by dots.
1519  * ----------
1520  */
1521 bool
1522 plpgsql_parse_tripword(char *word1, char *word2, char *word3,
1523  PLwdatum *wdatum, PLcword *cword)
1524 {
1525  PLpgSQL_nsitem *ns;
1526  List *idents;
1527  int nnames;
1528 
1529  idents = list_make3(makeString(word1),
1530  makeString(word2),
1531  makeString(word3));
1532 
1533  /*
1534  * We should do nothing in DECLARE sections. In SQL expressions, we
1535  * really only need to make sure that RECFIELD datums are created when
1536  * needed.
1537  */
1538  if (plpgsql_IdentifierLookup != IDENTIFIER_LOOKUP_DECLARE)
1539  {
1540  /*
1541  * Do a lookup in the current namespace stack. Must find a qualified
1542  * reference, else ignore.
1543  */
1544  ns = plpgsql_ns_lookup(plpgsql_ns_top(), false,
1545  word1, word2, word3,
1546  &nnames);
1547  if (ns != NULL && nnames == 2)
1548  {
1549  switch (ns->itemtype)
1550  {
1551  case PLPGSQL_NSTYPE_REC:
1552  {
1553  /*
1554  * words 1/2 are a record name, so third word could be
1555  * a field in this record.
1556  */
1557  PLpgSQL_rec *rec;
1558  PLpgSQL_recfield *new;
1559 
1560  rec = (PLpgSQL_rec *) (plpgsql_Datums[ns->itemno]);
1561  new = plpgsql_build_recfield(rec, word3);
1562 
1563  wdatum->datum = (PLpgSQL_datum *) new;
1564  wdatum->ident = NULL;
1565  wdatum->quoted = false; /* not used */
1566  wdatum->idents = idents;
1567  return true;
1568  }
1569 
1570  default:
1571  break;
1572  }
1573  }
1574  }
1575 
1576  /* Nothing found */
1577  cword->idents = idents;
1578  return false;
1579 }
1580 
1581 
1582 /* ----------
1583  * plpgsql_parse_wordtype The scanner found word%TYPE. word can be
1584  * a variable name or a basetype.
1585  *
1586  * Returns datatype struct, or NULL if no match found for word.
1587  * ----------
1588  */
1589 PLpgSQL_type *
1590 plpgsql_parse_wordtype(char *ident)
1591 {
1592  PLpgSQL_type *dtype;
1593  PLpgSQL_nsitem *nse;
1594  TypeName *typeName;
1595  HeapTuple typeTup;
1596 
1597  /*
1598  * Do a lookup in the current namespace stack
1599  */
1600  nse = plpgsql_ns_lookup(plpgsql_ns_top(), false,
1601  ident, NULL, NULL,
1602  NULL);
1603 
1604  if (nse != NULL)
1605  {
1606  switch (nse->itemtype)
1607  {
1608  case PLPGSQL_NSTYPE_VAR:
1609  return ((PLpgSQL_var *) (plpgsql_Datums[nse->itemno]))->datatype;
1610 
1611  /* XXX perhaps allow REC/ROW here? */
1612 
1613  default:
1614  return NULL;
1615  }
1616  }
1617 
1618  /*
1619  * Word wasn't found in the namespace stack. Try to find a data type with
1620  * that name, but ignore shell types and complex types.
1621  */
1622  typeName = makeTypeName(ident);
1623  typeTup = LookupTypeName(NULL, typeName, NULL, false);
1624  if (typeTup)
1625  {
1626  Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
1627 
1628  if (!typeStruct->typisdefined ||
1629  typeStruct->typrelid != InvalidOid)
1630  {
1631  ReleaseSysCache(typeTup);
1632  return NULL;
1633  }
1634 
1635  dtype = build_datatype(typeTup, -1,
1636  plpgsql_curr_compile->fn_input_collation,
1637  typeName);
1638 
1639  ReleaseSysCache(typeTup);
1640  return dtype;
1641  }
1642 
1643  /*
1644  * Nothing found - up to now it's a word without any special meaning for
1645  * us.
1646  */
1647  return NULL;
1648 }
1649 
1650 
1651 /* ----------
1652  * plpgsql_parse_cwordtype Same lookup for compositeword%TYPE
1653  * ----------
1654  */
1655 PLpgSQL_type *
1656 plpgsql_parse_cwordtype(List *idents)
1657 {
1658  PLpgSQL_type *dtype = NULL;
1659  PLpgSQL_nsitem *nse;
1660  const char *fldname;
1661  Oid classOid;
1662  HeapTuple classtup = NULL;
1663  HeapTuple attrtup = NULL;
1664  HeapTuple typetup = NULL;
1665  Form_pg_class classStruct;
1666  Form_pg_attribute attrStruct;
1667  MemoryContext oldCxt;
1668 
1669  /* Avoid memory leaks in the long-term function context */
1670  oldCxt = MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
1671 
1672  if (list_length(idents) == 2)
1673  {
1674  /*
1675  * Do a lookup in the current namespace stack. We don't need to check
1676  * number of names matched, because we will only consider scalar
1677  * variables.
1678  */
1679  nse = plpgsql_ns_lookup(plpgsql_ns_top(), false,
1680  strVal(linitial(idents)),
1681  strVal(lsecond(idents)),
1682  NULL,
1683  NULL);
1684 
1685  if (nse != NULL && nse->itemtype == PLPGSQL_NSTYPE_VAR)
1686  {
1687  dtype = ((PLpgSQL_var *) (plpgsql_Datums[nse->itemno]))->datatype;
1688  goto done;
1689  }
1690 
1691  /*
1692  * First word could also be a table name
1693  */
1694  classOid = RelnameGetRelid(strVal(linitial(idents)));
1695  if (!OidIsValid(classOid))
1696  goto done;
1697  fldname = strVal(lsecond(idents));
1698  }
1699  else if (list_length(idents) == 3)
1700  {
1701  RangeVar *relvar;
1702 
1703  relvar = makeRangeVar(strVal(linitial(idents)),
1704  strVal(lsecond(idents)),
1705  -1);
1706  /* Can't lock relation - we might not have privileges. */
1707  classOid = RangeVarGetRelid(relvar, NoLock, true);
1708  if (!OidIsValid(classOid))
1709  goto done;
1710  fldname = strVal(lthird(idents));
1711  }
1712  else
1713  goto done;
1714 
1715  classtup = SearchSysCache1(RELOID, ObjectIdGetDatum(classOid));
1716  if (!HeapTupleIsValid(classtup))
1717  goto done;
1718  classStruct = (Form_pg_class) GETSTRUCT(classtup);
1719 
1720  /*
1721  * It must be a relation, sequence, view, materialized view, composite
1722  * type, or foreign table
1723  */
1724  if (classStruct->relkind != RELKIND_RELATION &&
1725  classStruct->relkind != RELKIND_SEQUENCE &&
1726  classStruct->relkind != RELKIND_VIEW &&
1727  classStruct->relkind != RELKIND_MATVIEW &&
1728  classStruct->relkind != RELKIND_COMPOSITE_TYPE &&
1729  classStruct->relkind != RELKIND_FOREIGN_TABLE &&
1730  classStruct->relkind != RELKIND_PARTITIONED_TABLE)
1731  goto done;
1732 
1733  /*
1734  * Fetch the named table field and its type
1735  */
1736  attrtup = SearchSysCacheAttName(classOid, fldname);
1737  if (!HeapTupleIsValid(attrtup))
1738  goto done;
1739  attrStruct = (Form_pg_attribute) GETSTRUCT(attrtup);
1740 
1741  typetup = SearchSysCache1(TYPEOID,
1742  ObjectIdGetDatum(attrStruct->atttypid));
1743  if (!HeapTupleIsValid(typetup))
1744  elog(ERROR, "cache lookup failed for type %u", attrStruct->atttypid);
1745 
1746  /*
1747  * Found that - build a compiler type struct in the caller's cxt and
1748  * return it. Note that we treat the type as being found-by-OID; no
1749  * attempt to re-look-up the type name will happen during invalidations.
1750  */
1751  MemoryContextSwitchTo(oldCxt);
1752  dtype = build_datatype(typetup,
1753  attrStruct->atttypmod,
1754  attrStruct->attcollation,
1755  NULL);
1756  MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
1757 
1758 done:
1759  if (HeapTupleIsValid(classtup))
1760  ReleaseSysCache(classtup);
1761  if (HeapTupleIsValid(attrtup))
1762  ReleaseSysCache(attrtup);
1763  if (HeapTupleIsValid(typetup))
1764  ReleaseSysCache(typetup);
1765 
1766  MemoryContextSwitchTo(oldCxt);
1767  return dtype;
1768 }
1769 
1770 /* ----------
1771  * plpgsql_parse_wordrowtype Scanner found word%ROWTYPE.
1772  * So word must be a table name.
1773  * ----------
1774  */
1775 PLpgSQL_type *
1776 plpgsql_parse_wordrowtype(char *ident)
1777 {
1778  Oid classOid;
1779 
1780  /*
1781  * Look up the relation. Note that because relation rowtypes have the
1782  * same names as their relations, this could be handled as a type lookup
1783  * equally well; we use the relation lookup code path only because the
1784  * errors thrown here have traditionally referred to relations not types.
1785  * But we'll make a TypeName in case we have to do re-look-up of the type.
1786  */
1787  classOid = RelnameGetRelid(ident);
1788  if (!OidIsValid(classOid))
1789  ereport(ERROR,
1790  (errcode(ERRCODE_UNDEFINED_TABLE),
1791  errmsg("relation \"%s\" does not exist", ident)));
1792 
1793  /* Build and return the row type struct */
1794  return plpgsql_build_datatype(get_rel_type_id(classOid), -1, InvalidOid,
1795  makeTypeName(ident));
1796 }
1797 
1798 /* ----------
1799  * plpgsql_parse_cwordrowtype Scanner found compositeword%ROWTYPE.
1800  * So word must be a namespace qualified table name.
1801  * ----------
1802  */
1803 PLpgSQL_type *
1804 plpgsql_parse_cwordrowtype(List *idents)
1805 {
1806  Oid classOid;
1807  RangeVar *relvar;
1808  MemoryContext oldCxt;
1809 
1810  /*
1811  * As above, this is a relation lookup but could be a type lookup if we
1812  * weren't being backwards-compatible about error wording.
1813  */
1814  if (list_length(idents) != 2)
1815  return NULL;
1816 
1817  /* Avoid memory leaks in long-term function context */
1818  oldCxt = MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
1819 
1820  /* Look up relation name. Can't lock it - we might not have privileges. */
1821  relvar = makeRangeVar(strVal(linitial(idents)),
1822  strVal(lsecond(idents)),
1823  -1);
1824  classOid = RangeVarGetRelid(relvar, NoLock, false);
1825 
1826  MemoryContextSwitchTo(oldCxt);
1827 
1828  /* Build and return the row type struct */
1829  return plpgsql_build_datatype(get_rel_type_id(classOid), -1, InvalidOid,
1830  makeTypeNameFromNameList(idents));
1831 }
1832 
1833 /*
1834  * plpgsql_build_variable - build a datum-array entry of a given
1835  * datatype
1836  *
1837  * The returned struct may be a PLpgSQL_var or PLpgSQL_rec
1838  * depending on the given datatype, and is allocated via
1839  * palloc. The struct is automatically added to the current datum
1840  * array, and optionally to the current namespace.
1841  */
1842 PLpgSQL_variable *
1843 plpgsql_build_variable(const char *refname, int lineno, PLpgSQL_type *dtype,
1844  bool add2namespace)
1845 {
1846  PLpgSQL_variable *result;
1847 
1848  switch (dtype->ttype)
1849  {
1850  case PLPGSQL_TTYPE_SCALAR:
1851  {
1852  /* Ordinary scalar datatype */
1853  PLpgSQL_var *var;
1854 
1855  var = palloc0(sizeof(PLpgSQL_var));
1856  var->dtype = PLPGSQL_DTYPE_VAR;
1857  var->refname = pstrdup(refname);
1858  var->lineno = lineno;
1859  var->datatype = dtype;
1860  /* other fields are left as 0, might be changed by caller */
1861 
1862  /* preset to NULL */
1863  var->value = 0;
1864  var->isnull = true;
1865  var->freeval = false;
1866 
1867  plpgsql_adddatum((PLpgSQL_datum *) var);
1868  if (add2namespace)
1869  plpgsql_ns_additem(PLPGSQL_NSTYPE_VAR,
1870  var->dno,
1871  refname);
1872  result = (PLpgSQL_variable *) var;
1873  break;
1874  }
1875  case PLPGSQL_TTYPE_REC:
1876  {
1877  /* Composite type -- build a record variable */
1878  PLpgSQL_rec *rec;
1879 
1880  rec = plpgsql_build_record(refname, lineno,
1881  dtype, dtype->typoid,
1882  add2namespace);
1883  result = (PLpgSQL_variable *) rec;
1884  break;
1885  }
1886  case PLPGSQL_TTYPE_PSEUDO:
1887  ereport(ERROR,
1888  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1889  errmsg("variable \"%s\" has pseudo-type %s",
1890  refname, format_type_be(dtype->typoid))));
1891  result = NULL; /* keep compiler quiet */
1892  break;
1893  default:
1894  elog(ERROR, "unrecognized ttype: %d", dtype->ttype);
1895  result = NULL; /* keep compiler quiet */
1896  break;
1897  }
1898 
1899  return result;
1900 }
1901 
1902 /*
1903  * Build empty named record variable, and optionally add it to namespace
1904  */
1905 PLpgSQL_rec *
1906 plpgsql_build_record(const char *refname, int lineno,
1907  PLpgSQL_type *dtype, Oid rectypeid,
1908  bool add2namespace)
1909 {
1910  PLpgSQL_rec *rec;
1911 
1912  rec = palloc0(sizeof(PLpgSQL_rec));
1913  rec->dtype = PLPGSQL_DTYPE_REC;
1914  rec->refname = pstrdup(refname);
1915  rec->lineno = lineno;
1916  /* other fields are left as 0, might be changed by caller */
1917  rec->datatype = dtype;
1918  rec->rectypeid = rectypeid;
1919  rec->firstfield = -1;
1920  rec->erh = NULL;
1921  plpgsql_adddatum((PLpgSQL_datum *) rec);
1922  if (add2namespace)
1923  plpgsql_ns_additem(PLPGSQL_NSTYPE_REC, rec->dno, rec->refname);
1924 
1925  return rec;
1926 }
1927 
1928 /*
1929  * Build a row-variable data structure given the component variables.
1930  * Include a rowtupdesc, since we will need to materialize the row result.
1931  */
1932 static PLpgSQL_row *
1933 build_row_from_vars(PLpgSQL_variable **vars, int numvars)
1934 {
1935  PLpgSQL_row *row;
1936  int i;
1937 
1938  row = palloc0(sizeof(PLpgSQL_row));
1939  row->dtype = PLPGSQL_DTYPE_ROW;
1940  row->refname = "(unnamed row)";
1941  row->lineno = -1;
1942  row->rowtupdesc = CreateTemplateTupleDesc(numvars);
1943  row->nfields = numvars;
1944  row->fieldnames = palloc(numvars * sizeof(char *));
1945  row->varnos = palloc(numvars * sizeof(int));
1946 
1947  for (i = 0; i < numvars; i++)
1948  {
1949  PLpgSQL_variable *var = vars[i];
1950  Oid typoid;
1951  int32 typmod;
1952  Oid typcoll;
1953 
1954  /* Member vars of a row should never be const */
1955  Assert(!var->isconst);
1956 
1957  switch (var->dtype)
1958  {
1959  case PLPGSQL_DTYPE_VAR:
1960  case PLPGSQL_DTYPE_PROMISE:
1961  typoid = ((PLpgSQL_var *) var)->datatype->typoid;
1962  typmod = ((PLpgSQL_var *) var)->datatype->atttypmod;
1963  typcoll = ((PLpgSQL_var *) var)->datatype->collation;
1964  break;
1965 
1966  case PLPGSQL_DTYPE_REC:
1967  /* shouldn't need to revalidate rectypeid already... */
1968  typoid = ((PLpgSQL_rec *) var)->rectypeid;
1969  typmod = -1; /* don't know typmod, if it's used at all */
1970  typcoll = InvalidOid; /* composite types have no collation */
1971  break;
1972 
1973  default:
1974  elog(ERROR, "unrecognized dtype: %d", var->dtype);
1975  typoid = InvalidOid; /* keep compiler quiet */
1976  typmod = 0;
1977  typcoll = InvalidOid;
1978  break;
1979  }
1980 
1981  row->fieldnames[i] = var->refname;
1982  row->varnos[i] = var->dno;
1983 
1984  TupleDescInitEntry(row->rowtupdesc, i + 1,
1985  var->refname,
1986  typoid, typmod,
1987  0);
1988  TupleDescInitEntryCollation(row->rowtupdesc, i + 1, typcoll);
1989  }
1990 
1991  return row;
1992 }
1993 
1994 /*
1995  * Build a RECFIELD datum for the named field of the specified record variable
1996  *
1997  * If there's already such a datum, just return it; we don't need duplicates.
1998  */
1999 PLpgSQL_recfield *
2000 plpgsql_build_recfield(PLpgSQL_rec *rec, const char *fldname)
2001 {
2002  PLpgSQL_recfield *recfield;
2003  int i;
2004 
2005  /* search for an existing datum referencing this field */
2006  i = rec->firstfield;
2007  while (i >= 0)
2008  {
2009  PLpgSQL_recfield *fld = (PLpgSQL_recfield *) plpgsql_Datums[i];
2010 
2011  Assert(fld->dtype == PLPGSQL_DTYPE_RECFIELD &&
2012  fld->recparentno == rec->dno);
2013  if (strcmp(fld->fieldname, fldname) == 0)
2014  return fld;
2015  i = fld->nextfield;
2016  }
2017 
2018  /* nope, so make a new one */
2019  recfield = palloc0(sizeof(PLpgSQL_recfield));
2020  recfield->dtype = PLPGSQL_DTYPE_RECFIELD;
2021  recfield->fieldname = pstrdup(fldname);
2022  recfield->recparentno = rec->dno;
2023  recfield->rectupledescid = INVALID_TUPLEDESC_IDENTIFIER;
2024 
2025  plpgsql_adddatum((PLpgSQL_datum *) recfield);
2026 
2027  /* now we can link it into the parent's chain */
2028  recfield->nextfield = rec->firstfield;
2029  rec->firstfield = recfield->dno;
2030 
2031  return recfield;
2032 }
2033 
2034 /*
2035  * plpgsql_build_datatype
2036  * Build PLpgSQL_type struct given type OID, typmod, collation,
2037  * and type's parsed name.
2038  *
2039  * If collation is not InvalidOid then it overrides the type's default
2040  * collation. But collation is ignored if the datatype is non-collatable.
2041  *
2042  * origtypname is the parsed form of what the user wrote as the type name.
2043  * It can be NULL if the type could not be a composite type, or if it was
2044  * identified by OID to begin with (e.g., it's a function argument type).
2045  */
2046 PLpgSQL_type *
2047 plpgsql_build_datatype(Oid typeOid, int32 typmod,
2048  Oid collation, TypeName *origtypname)
2049 {
2050  HeapTuple typeTup;
2051  PLpgSQL_type *typ;
2052 
2053  typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typeOid));
2054  if (!HeapTupleIsValid(typeTup))
2055  elog(ERROR, "cache lookup failed for type %u", typeOid);
2056 
2057  typ = build_datatype(typeTup, typmod, collation, origtypname);
2058 
2059  ReleaseSysCache(typeTup);
2060 
2061  return typ;
2062 }
2063 
2064 /*
2065  * Utility subroutine to make a PLpgSQL_type struct given a pg_type entry
2066  * and additional details (see comments for plpgsql_build_datatype).
2067  */
2068 static PLpgSQL_type *
2069 build_datatype(HeapTuple typeTup, int32 typmod,
2070  Oid collation, TypeName *origtypname)
2071 {
2072  Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
2073  PLpgSQL_type *typ;
2074 
2075  if (!typeStruct->typisdefined)
2076  ereport(ERROR,
2077  (errcode(ERRCODE_UNDEFINED_OBJECT),
2078  errmsg("type \"%s\" is only a shell",
2079  NameStr(typeStruct->typname))));
2080 
2081  typ = (PLpgSQL_type *) palloc(sizeof(PLpgSQL_type));
2082 
2083  typ->typname = pstrdup(NameStr(typeStruct->typname));
2084  typ->typoid = typeStruct->oid;
2085  switch (typeStruct->typtype)
2086  {
2087  case TYPTYPE_BASE:
2088  case TYPTYPE_ENUM:
2089  case TYPTYPE_RANGE:
2090  typ->ttype = PLPGSQL_TTYPE_SCALAR;
2091  break;
2092  case TYPTYPE_COMPOSITE:
2093  typ->ttype = PLPGSQL_TTYPE_REC;
2094  break;
2095  case TYPTYPE_DOMAIN:
2096  if (type_is_rowtype(typeStruct->typbasetype))
2097  typ->ttype = PLPGSQL_TTYPE_REC;
2098  else
2099  typ->ttype = PLPGSQL_TTYPE_SCALAR;
2100  break;
2101  case TYPTYPE_PSEUDO:
2102  if (typ->typoid == RECORDOID)
2103  typ->ttype = PLPGSQL_TTYPE_REC;
2104  else
2105  typ->ttype = PLPGSQL_TTYPE_PSEUDO;
2106  break;
2107  default:
2108  elog(ERROR, "unrecognized typtype: %d",
2109  (int) typeStruct->typtype);
2110  break;
2111  }
2112  typ->typlen = typeStruct->typlen;
2113  typ->typbyval = typeStruct->typbyval;
2114  typ->typtype = typeStruct->typtype;
2115  typ->collation = typeStruct->typcollation;
2116  if (OidIsValid(collation) && OidIsValid(typ->collation))
2117  typ->collation = collation;
2118  /* Detect if type is true array, or domain thereof */
2119  /* NB: this is only used to decide whether to apply expand_array */
2120  if (typeStruct->typtype == TYPTYPE_BASE)
2121  {
2122  /*
2123  * This test should include what get_element_type() checks. We also
2124  * disallow non-toastable array types (i.e. oidvector and int2vector).
2125  */
2126  typ->typisarray = (typeStruct->typlen == -1 &&
2127  OidIsValid(typeStruct->typelem) &&
2128  typeStruct->typstorage != 'p');
2129  }
2130  else if (typeStruct->typtype == TYPTYPE_DOMAIN)
2131  {
2132  /* we can short-circuit looking up base types if it's not varlena */
2133  typ->typisarray = (typeStruct->typlen == -1 &&
2134  typeStruct->typstorage != 'p' &&
2135  OidIsValid(get_base_element_type(typeStruct->typbasetype)));
2136  }
2137  else
2138  typ->typisarray = false;
2139  typ->atttypmod = typmod;
2140 
2141  /*
2142  * If it's a named composite type (or domain over one), find the typcache
2143  * entry and record the current tupdesc ID, so we can detect changes
2144  * (including drops). We don't currently support on-the-fly replacement
2145  * of non-composite types, else we might want to do this for them too.
2146  */
2147  if (typ->ttype == PLPGSQL_TTYPE_REC && typ->typoid != RECORDOID)
2148  {
2149  TypeCacheEntry *typentry;
2150 
2151  typentry = lookup_type_cache(typ->typoid,
2152  TYPECACHE_TUPDESC |
2153  TYPECACHE_DOMAIN_BASE_INFO);
2154  if (typentry->typtype == TYPTYPE_DOMAIN)
2155  typentry = lookup_type_cache(typentry->domainBaseType,
2156  TYPECACHE_TUPDESC);
2157  if (typentry->tupDesc == NULL)
2158  ereport(ERROR,
2159  (errcode(ERRCODE_WRONG_OBJECT_TYPE),
2160  errmsg("type %s is not composite",
2161  format_type_be(typ->typoid))));
2162 
2163  typ->origtypname = origtypname;
2164  typ->tcache = typentry;
2165  typ->tupdesc_id = typentry->tupDesc_identifier;
2166  }
2167  else
2168  {
2169  typ->origtypname = NULL;
2170  typ->tcache = NULL;
2171  typ->tupdesc_id = 0;
2172  }
2173 
2174  return typ;
2175 }
2176 
2177 /*
2178  * plpgsql_recognize_err_condition
2179  * Check condition name and translate it to SQLSTATE.
2180  *
2181  * Note: there are some cases where the same condition name has multiple
2182  * entries in the table. We arbitrarily return the first match.
2183  */
2184 int
2185 plpgsql_recognize_err_condition(const char *condname, bool allow_sqlstate)
2186 {
2187  int i;
2188 
2189  if (allow_sqlstate)
2190  {
2191  if (strlen(condname) == 5 &&
2192  strspn(condname, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") == 5)
2193  return MAKE_SQLSTATE(condname[0],
2194  condname[1],
2195  condname[2],
2196  condname[3],
2197  condname[4]);
2198  }
2199 
2200  for (i = 0; exception_label_map[i].label != NULL; i++)
2201  {
2202  if (strcmp(condname, exception_label_map[i].label) == 0)
2203  return exception_label_map[i].sqlerrstate;
2204  }
2205 
2206  ereport(ERROR,
2207  (errcode(ERRCODE_UNDEFINED_OBJECT),
2208  errmsg("unrecognized exception condition \"%s\"",
2209  condname)));
2210  return 0; /* keep compiler quiet */
2211 }
2212 
2213 /*
2214  * plpgsql_parse_err_condition
2215  * Generate PLpgSQL_condition entry(s) for an exception condition name
2216  *
2217  * This has to be able to return a list because there are some duplicate
2218  * names in the table of error code names.
2219  */
2220 PLpgSQL_condition *
2221 plpgsql_parse_err_condition(char *condname)
2222 {
2223  int i;
2224  PLpgSQL_condition *new;
2225  PLpgSQL_condition *prev;
2226 
2227  /*
2228  * XXX Eventually we will want to look for user-defined exception names
2229  * here.
2230  */
2231 
2232  /*
2233  * OTHERS is represented as code 0 (which would map to '00000', but we
2234  * have no need to represent that as an exception condition).
2235  */
2236  if (strcmp(condname, "others") == 0)
2237  {
2238  new = palloc(sizeof(PLpgSQL_condition));
2239  new->sqlerrstate = 0;
2240  new->condname = condname;
2241  new->next = NULL;
2242  return new;
2243  }
2244 
2245  prev = NULL;
2246  for (i = 0; exception_label_map[i].label != NULL; i++)
2247  {
2248  if (strcmp(condname, exception_label_map[i].label) == 0)
2249  {
2250  new = palloc(sizeof(PLpgSQL_condition));
2251  new->sqlerrstate = exception_label_map[i].sqlerrstate;
2252  new->condname = condname;
2253  new->next = prev;
2254  prev = new;
2255  }
2256  }
2257 
2258  if (!prev)
2259  ereport(ERROR,
2260  (errcode(ERRCODE_UNDEFINED_OBJECT),
2261  errmsg("unrecognized exception condition \"%s\"",
2262  condname)));
2263 
2264  return prev;
2265 }
2266 
2267 /* ----------
2268  * plpgsql_start_datums Initialize datum list at compile startup.
2269  * ----------
2270  */
2271 static void
2272 plpgsql_start_datums(void)
2273 {
2274  datums_alloc = 128;
2275  plpgsql_nDatums = 0;
2276  /* This is short-lived, so needn't allocate in function's cxt */
2277  plpgsql_Datums = MemoryContextAlloc(plpgsql_compile_tmp_cxt,
2278  sizeof(PLpgSQL_datum *) * datums_alloc);
2279  /* datums_last tracks what's been seen by plpgsql_add_initdatums() */
2280  datums_last = 0;
2281 }
2282 
2283 /* ----------
2284  * plpgsql_adddatum Add a variable, record or row
2285  * to the compiler's datum list.
2286  * ----------
2287  */
2288 void
2289 plpgsql_adddatum(PLpgSQL_datum *newdatum)
2290 {
2291  if (plpgsql_nDatums == datums_alloc)
2292  {
2293  datums_alloc *= 2;
2294  plpgsql_Datums = repalloc(plpgsql_Datums, sizeof(PLpgSQL_datum *) * datums_alloc);
2295  }
2296 
2297  newdatum->dno = plpgsql_nDatums;
2298  plpgsql_Datums[plpgsql_nDatums++] = newdatum;
2299 }
2300 
2301 /* ----------
2302  * plpgsql_finish_datums Copy completed datum info into function struct.
2303  * ----------
2304  */
2305 static void
2306 plpgsql_finish_datums(PLpgSQL_function *function)
2307 {
2308  Size copiable_size = 0;
2309  int i;
2310 
2311  function->ndatums = plpgsql_nDatums;
2312  function->datums = palloc(sizeof(PLpgSQL_datum *) * plpgsql_nDatums);
2313  for (i = 0; i < plpgsql_nDatums; i++)
2314  {
2315  function->datums[i] = plpgsql_Datums[i];
2316 
2317  /* This must agree with copy_plpgsql_datums on what is copiable */
2318  switch (function->datums[i]->dtype)
2319  {
2320  case PLPGSQL_DTYPE_VAR:
2321  case PLPGSQL_DTYPE_PROMISE:
2322  copiable_size += MAXALIGN(sizeof(PLpgSQL_var));
2323  break;
2324  case PLPGSQL_DTYPE_REC:
2325  copiable_size += MAXALIGN(sizeof(PLpgSQL_rec));
2326  break;
2327  default:
2328  break;
2329  }
2330  }
2331  function->copiable_size = copiable_size;
2332 }
2333 
2334 
2335 /* ----------
2336  * plpgsql_add_initdatums Make an array of the datum numbers of
2337  * all the initializable datums created since the last call
2338  * to this function.
2339  *
2340  * If varnos is NULL, we just forget any datum entries created since the
2341  * last call.
2342  *
2343  * This is used around a DECLARE section to create a list of the datums
2344  * that have to be initialized at block entry. Note that datums can also
2345  * be created elsewhere than DECLARE, eg by a FOR-loop, but it is then
2346  * the responsibility of special-purpose code to initialize them.
2347  * ----------
2348  */
2349 int
2350 plpgsql_add_initdatums(int **varnos)
2351 {
2352  int i;
2353  int n = 0;
2354 
2355  /*
2356  * The set of dtypes recognized here must match what exec_stmt_block()
2357  * cares about (re)initializing at block entry.
2358  */
2359  for (i = datums_last; i < plpgsql_nDatums; i++)
2360  {
2361  switch (plpgsql_Datums[i]->dtype)
2362  {
2363  case PLPGSQL_DTYPE_VAR:
2364  case PLPGSQL_DTYPE_REC:
2365  n++;
2366  break;
2367 
2368  default:
2369  break;
2370  }
2371  }
2372 
2373  if (varnos != NULL)
2374  {
2375  if (n > 0)
2376  {
2377  *varnos = (int *) palloc(sizeof(int) * n);
2378 
2379  n = 0;
2380  for (i = datums_last; i < plpgsql_nDatums; i++)
2381  {
2382  switch (plpgsql_Datums[i]->dtype)
2383  {
2384  case PLPGSQL_DTYPE_VAR:
2385  case PLPGSQL_DTYPE_REC:
2386  (*varnos)[n++] = plpgsql_Datums[i]->dno;
2387 
2388  default:
2389  break;
2390  }
2391  }
2392  }
2393  else
2394  *varnos = NULL;
2395  }
2396 
2397  datums_last = plpgsql_nDatums;
2398  return n;
2399 }
2400 
2401 
2402 /*
2403  * Compute the hashkey for a given function invocation
2404  *
2405  * The hashkey is returned into the caller-provided storage at *hashkey.
2406  */
2407 static void
2408 compute_function_hashkey(FunctionCallInfo fcinfo,
2409  Form_pg_proc procStruct,
2410  PLpgSQL_func_hashkey *hashkey,
2411  bool forValidator)
2412 {
2413  /* Make sure any unused bytes of the struct are zero */
2414  MemSet(hashkey, 0, sizeof(PLpgSQL_func_hashkey));
2415 
2416  /* get function OID */
2417  hashkey->funcOid = fcinfo->flinfo->fn_oid;
2418 
2419  /* get call context */
2420  hashkey->isTrigger = CALLED_AS_TRIGGER(fcinfo);
2421 
2422  /*
2423  * if trigger, get its OID. In validation mode we do not know what
2424  * relation or transition table names are intended to be used, so we leave
2425  * trigOid zero; the hash entry built in this case will never really be
2426  * used.
2427  */
2428  if (hashkey->isTrigger && !forValidator)
2429  {
2430  TriggerData *trigdata = (TriggerData *) fcinfo->context;
2431 
2432  hashkey->trigOid = trigdata->tg_trigger->tgoid;
2433  }
2434 
2435  /* get input collation, if known */
2436  hashkey->inputCollation = fcinfo->fncollation;
2437 
2438  if (procStruct->pronargs > 0)
2439  {
2440  /* get the argument types */
2441  memcpy(hashkey->argtypes, procStruct->proargtypes.values,
2442  procStruct->pronargs * sizeof(Oid));
2443 
2444  /* resolve any polymorphic argument types */
2445  plpgsql_resolve_polymorphic_argtypes(procStruct->pronargs,
2446  hashkey->argtypes,
2447  NULL,
2448  fcinfo->flinfo->fn_expr,
2449  forValidator,
2450  NameStr(procStruct->proname));
2451  }
2452 }
2453 
2454 /*
2455  * This is the same as the standard resolve_polymorphic_argtypes() function,
2456  * but with a special case for validation: assume that polymorphic arguments
2457  * are integer, integer-array or integer-range. Also, we go ahead and report
2458  * the error if we can't resolve the types.
2459  */
2460 static void
2461 plpgsql_resolve_polymorphic_argtypes(int numargs,
2462  Oid *argtypes, char *argmodes,
2463  Node *call_expr, bool forValidator,
2464  const char *proname)
2465 {
2466  int i;
2467 
2468  if (!forValidator)
2469  {
2470  /* normal case, pass to standard routine */
2471  if (!resolve_polymorphic_argtypes(numargs, argtypes, argmodes,
2472  call_expr))
2473  ereport(ERROR,
2474  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2475  errmsg("could not determine actual argument "
2476  "type for polymorphic function \"%s\"",
2477  proname)));
2478  }
2479  else
2480  {
2481  /* special validation case */
2482  for (i = 0; i < numargs; i++)
2483  {
2484  switch (argtypes[i])
2485  {
2486  case ANYELEMENTOID:
2487  case ANYNONARRAYOID:
2488  case ANYENUMOID: /* XXX dubious */
2489  argtypes[i] = INT4OID;
2490  break;
2491  case ANYARRAYOID:
2492  argtypes[i] = INT4ARRAYOID;
2493  break;
2494  case ANYRANGEOID:
2495  argtypes[i] = INT4RANGEOID;
2496  break;
2497  default:
2498  break;
2499  }
2500  }
2501  }
2502 }
2503 
2504 /*
2505  * delete_function - clean up as much as possible of a stale function cache
2506  *
2507  * We can't release the PLpgSQL_function struct itself, because of the
2508  * possibility that there are fn_extra pointers to it. We can release
2509  * the subsidiary storage, but only if there are no active evaluations
2510  * in progress. Otherwise we'll just leak that storage. Since the
2511  * case would only occur if a pg_proc update is detected during a nested
2512  * recursive call on the function, a leak seems acceptable.
2513  *
2514  * Note that this can be called more than once if there are multiple fn_extra
2515  * pointers to the same function cache. Hence be careful not to do things
2516  * twice.
2517  */
2518 static void
2519 delete_function(PLpgSQL_function *func)
2520 {
2521  /* remove function from hash table (might be done already) */
2522  plpgsql_HashTableDelete(func);
2523 
2524  /* release the function's storage if safe and not done already */
2525  if (func->use_count == 0)
2526  plpgsql_free_function_memory(func);
2527 }
2528 
2529 /* exported so we can call it from _PG_init() */
2530 void
2531 plpgsql_HashTableInit(void)
2532 {
2533  HASHCTL ctl;
2534 
2535  /* don't allow double-initialization */
2536  Assert(plpgsql_HashTable == NULL);
2537 
2538  memset(&ctl, 0, sizeof(ctl));
2539  ctl.keysize = sizeof(PLpgSQL_func_hashkey);
2540  ctl.entrysize = sizeof(plpgsql_HashEnt);
2541  plpgsql_HashTable = hash_create("PLpgSQL function hash",
2542  FUNCS_PER_USER,
2543  &ctl,
2544  HASH_ELEM | HASH_BLOBS);
2545 }
2546 
2547 static PLpgSQL_function *
2548 plpgsql_HashTableLookup(PLpgSQL_func_hashkey *func_key)
2549 {
2550  plpgsql_HashEnt *hentry;
2551 
2552  hentry = (plpgsql_HashEnt *) hash_search(plpgsql_HashTable,
2553  (void *) func_key,
2554  HASH_FIND,
2555  NULL);
2556  if (hentry)
2557  return hentry->function;
2558  else
2559  return NULL;
2560 }
2561 
2562 static void
2563 plpgsql_HashTableInsert(PLpgSQL_function *function,
2564  PLpgSQL_func_hashkey *func_key)
2565 {
2566  plpgsql_HashEnt *hentry;
2567  bool found;
2568 
2569  hentry = (plpgsql_HashEnt *) hash_search(plpgsql_HashTable,
2570  (void *) func_key,
2571  HASH_ENTER,
2572  &found);
2573  if (found)
2574  elog(WARNING, "trying to insert a function that already exists");
2575 
2576  hentry->function = function;
2577  /* prepare back link from function to hashtable key */
2578  function->fn_hashkey = &hentry->key;
2579 }
2580 
2581 static void
2582 plpgsql_HashTableDelete(PLpgSQL_function *function)
2583 {
2584  plpgsql_HashEnt *hentry;
2585 
2586  /* do nothing if not in table */
2587  if (function->fn_hashkey == NULL)
2588  return;
2589 
2590  hentry = (plpgsql_HashEnt *) hash_search(plpgsql_HashTable,
2591  (void *) function->fn_hashkey,
2592  HASH_REMOVE,
2593  NULL);
2594  if (hentry == NULL)
2595  elog(WARNING, "trying to delete function that does not exist");
2596 
2597  /* remove back link, which no longer points to allocated storage */
2598  function->fn_hashkey = NULL;
2599 }
list_make2
#define list_make2(x1, x2)
Definition: pg_list.h:229
makeString
Value * makeString(char *str)
Definition: value.c:53
resolve_polymorphic_argtypes
bool resolve_polymorphic_argtypes(int numargs, Oid *argtypes, char *argmodes, Node *call_expr)
Definition: funcapi.c:661
LookupTypeName
Type LookupTypeName(ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool missing_ok)
Definition: parse_type.c:38
plpgsql_compile_inline
PLpgSQL_function * plpgsql_compile_inline(char *proc_source)
Definition: pl_comp.c:841
list_make3
#define list_make3(x1, x2, x3)
Definition: pg_list.h:231
plpgsql_nDatums
int plpgsql_nDatums
Definition: pl_comp.c:44
plpgsql_yyparse
int plpgsql_yyparse(void)
PLpgSQL_rec::dtype
PLpgSQL_datum_type dtype
Definition: plpgsql.h:372
NIL
#define NIL
Definition: pg_list.h:65
FUNCS_PER_USER
#define FUNCS_PER_USER
Definition: pl_comp.c:69
plpgsql_latest_lineno
int plpgsql_latest_lineno(void)
Definition: pl_scanner.c:572
plpgsql_free_function_memory
void plpgsql_free_function_memory(PLpgSQL_function *func)
Definition: pl_funcs.c:737
PLpgSQL_func_hashkey::isTrigger
bool isTrigger
Definition: plpgsql.h:942
PLpgSQL_function::datums
PLpgSQL_datum ** datums
Definition: plpgsql.h:1021
PLpgSQL_function::fn_argvarnos
int fn_argvarnos[FUNC_MAX_ARGS]
Definition: plpgsql.h:1002
PLpgSQL_func_hashkey::argtypes
Oid argtypes[FUNC_MAX_ARGS]
Definition: plpgsql.h:965
CALLED_AS_EVENT_TRIGGER
#define CALLED_AS_EVENT_TRIGGER(fcinfo)
Definition: event_trigger.h:39
IsA
#define IsA(nodeptr, _type_)
Definition: nodes.h:576
PLpgSQL_recfield
Definition: plpgsql.h:401
plpgsql_Datums
PLpgSQL_datum ** plpgsql_Datums
Definition: pl_comp.c:45
AllocSetContextCreate
#define AllocSetContextCreate
Definition: memutils.h:170
PLpgSQL_function::fn_hashkey
PLpgSQL_func_hashkey * fn_hashkey
Definition: plpgsql.h:989
plpgsql_parse_wordrowtype
PLpgSQL_type * plpgsql_parse_wordrowtype(char *ident)
Definition: pl_comp.c:1776
PLpgSQL_row::refname
char * refname
Definition: plpgsql.h:348
PLpgSQL_function::fn_tid
ItemPointerData fn_tid
Definition: plpgsql.h:986
plpgsql_hashent
Definition: pl_comp.c:63
errhint
int errhint(const char *fmt,...)
Definition: elog.c:1069
PLpgSQL_type::tcache
TypeCacheEntry * tcache
Definition: plpgsql.h:212
do_compile
static PLpgSQL_function * do_compile(FunctionCallInfo fcinfo, HeapTuple procTup, PLpgSQL_function *function, PLpgSQL_func_hashkey *hashkey, bool forValidator)
Definition: pl_comp.c:263
plpgsql_ns_top
PLpgSQL_nsitem * plpgsql_ns_top(void)
Definition: pl_funcs.c:81
ExceptionLabelMap::label
const char * label
Definition: pl_comp.c:77
proname
NameData proname
Definition: pg_proc.h:35
plpgsql_parse_dblword
bool plpgsql_parse_dblword(char *word1, char *word2, PLwdatum *wdatum, PLcword *cword)
Definition: pl_comp.c:1442
GETSTRUCT
#define GETSTRUCT(TUP)
Definition: htup_details.h:655
ERRCODE_UNDEFINED_TABLE
#define ERRCODE_UNDEFINED_TABLE
Definition: pgbench.c:73
pg_proc.h
compute_function_hashkey
static void compute_function_hashkey(FunctionCallInfo fcinfo, Form_pg_proc procStruct, PLpgSQL_func_hashkey *hashkey, bool forValidator)
Definition: pl_comp.c:2408
plpgsql_hashent::key
PLpgSQL_func_hashkey key
Definition: pl_comp.c:65
PLpgSQL_var::refname
char * refname
Definition: plpgsql.h:294
HASH_ELEM
#define HASH_ELEM
Definition: hsearch.h:87
CreateTemplateTupleDesc
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:44
plpgsql_build_record
PLpgSQL_rec * plpgsql_build_record(const char *refname, int lineno, PLpgSQL_type *dtype, Oid rectypeid, bool add2namespace)
Definition: pl_comp.c:1906
PLpgSQL_rec::datatype
PLpgSQL_type * datatype
Definition: plpgsql.h:387
PLpgSQL_var::dtype
PLpgSQL_datum_type dtype
Definition: plpgsql.h:292
PLpgSQL_type::origtypname
TypeName * origtypname
Definition: plpgsql.h:211
PLpgSQL_function::action
PLpgSQL_stmt_block * action
Definition: plpgsql.h:1025
RelnameGetRelid
Oid RelnameGetRelid(const char *relname)
Definition: namespace.c:672
build_datatype
static PLpgSQL_type * build_datatype(HeapTuple typeTup, int32 typmod, Oid collation, TypeName *origtypname)
Definition: pl_comp.c:2069
MAKE_SQLSTATE
#define MAKE_SQLSTATE(ch1, ch2, ch3, ch4, ch5)
Definition: elog.h:62
plpgsql_pre_column_ref
static Node * plpgsql_pre_column_ref(ParseState *pstate, ColumnRef *cref)
Definition: pl_comp.c:1085
PLpgSQL_datum::dno
int dno
Definition: plpgsql.h:259
RangeVarGetRelid
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Definition: namespace.h:63
plpgsql_ns_lookup
PLpgSQL_nsitem * plpgsql_ns_lookup(PLpgSQL_nsitem *ns_cur, bool localmode, const char *name1, const char *name2, const char *name3, int *names_used)
Definition: pl_funcs.c:130
pstrdup
char * pstrdup(const char *in)
Definition: mcxt.c:1186
PLpgSQL_var::datatype
PLpgSQL_type * datatype
Definition: plpgsql.h:301
Trigger::tgoid
Oid tgoid
Definition: reltrigger.h:25
llast
#define llast(l)
Definition: pg_list.h:215
get_func_arg_info
int get_func_arg_info(HeapTuple procTup, Oid **p_argtypes, char ***p_argnames, char **p_argmodes)
Definition: funcapi.c:863
plpgsql_ns_additem
void plpgsql_ns_additem(PLpgSQL_nsitem_type itemtype, int itemno, const char *name)
Definition: pl_funcs.c:92
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
PLpgSQL_stmt_return
Definition: plpgsql.h:834
plpgsql_HashTableInit
void plpgsql_HashTableInit(void)
Definition: pl_comp.c:2531
PLpgSQL_type::ttype
PLpgSQL_type_type ttype
Definition: plpgsql.h:203
plpgsql_build_recfield
PLpgSQL_recfield * plpgsql_build_recfield(PLpgSQL_rec *rec, const char *fldname)
Definition: pl_comp.c:2000
HASHCTL::entrysize
Size entrysize
Definition: hsearch.h:73
Param::paramkind
ParamKind paramkind
Definition: primnodes.h:262
PLpgSQL_function::fn_xmin
TransactionId fn_xmin
Definition: plpgsql.h:985
Node
Definition: nodes.h:525
plpgsql_recognize_err_condition
int plpgsql_recognize_err_condition(const char *condname, bool allow_sqlstate)
Definition: pl_comp.c:2185
PLpgSQL_func_hashkey
Definition: plpgsql.h:938
plpgsql_extra_errors
int plpgsql_extra_errors
Definition: pl_handler.c:53
PLpgSQL_rec::erh
ExpandedRecordHeader * erh
Definition: plpgsql.h:395
plpgsql_parse_wordtype
PLpgSQL_type * plpgsql_parse_wordtype(char *ident)
Definition: pl_comp.c:1590
strVal
#define strVal(v)
Definition: value.h:54
errcode
int errcode(int sqlerrcode)
Definition: elog.c:608
MemSet
#define MemSet(start, val, len)
Definition: c.h:962
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:326
FunctionCallInfoBaseData::context
fmNodePtr context
Definition: fmgr.h:88
PLpgSQL_type::tupdesc_id
uint64 tupdesc_id
Definition: plpgsql.h:213
PLpgSQL_function::fn_rettype
Oid fn_rettype
Definition: plpgsql.h:992
PLpgSQL_type
Definition: plpgsql.h:199
hash_search
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
check_function_bodies
bool check_function_bodies
Definition: guc.c:509
plpgsql_dumptree
void plpgsql_dumptree(PLpgSQL_function *func)
Definition: pl_funcs.c:1624
PLword::ident
char * ident
Definition: plpgsql.h:1158
Oid
unsigned int Oid
Definition: postgres_ext.h:31
pg_type.h
PLpgSQL_datum::dtype
PLpgSQL_datum_type dtype
Definition: plpgsql.h:258
PLpgSQL_rec
Definition: plpgsql.h:370
ErrorContextCallback::callback
void(* callback)(void *arg)
Definition: elog.h:256
ErrorContextCallback::previous
struct ErrorContextCallback * previous
Definition: elog.h:255
OidIsValid
#define OidIsValid(objectId)
Definition: c.h:645
PLpgSQL_rec::refname
char * refname
Definition: plpgsql.h:374
PLpgSQL_function::fn_prokind
char fn_prokind
Definition: plpgsql.h:999
INVALID_TUPLEDESC_IDENTIFIER
#define INVALID_TUPLEDESC_IDENTIFIER
Definition: typcache.h:146
plpgsql_resolve_polymorphic_argtypes
static void plpgsql_resolve_polymorphic_argtypes(int numargs, Oid *argtypes, char *argmodes, Node *call_expr, bool forValidator, const char *proname)
Definition: pl_comp.c:2461
plpgsql_HashTableInsert
static void plpgsql_HashTableInsert(PLpgSQL_function *function, PLpgSQL_func_hashkey *func_key)
Definition: pl_comp.c:2563
lsecond
#define lsecond(l)
Definition: pg_list.h:200
plpgsql_start_datums
static void plpgsql_start_datums(void)
Definition: pl_comp.c:2272
PLpgSQL_var
Definition: plpgsql.h:290
PLpgSQL_row
Definition: plpgsql.h:344
ParseState::p_post_columnref_hook
PostParseColumnRefHook p_post_columnref_hook
Definition: parse_node.h:219
int32
signed int int32
Definition: c.h:347
plpgsql_adddatum
void plpgsql_adddatum(PLpgSQL_datum *newdatum)
Definition: pl_comp.c:2289
PLpgSQL_execstate::datums
PLpgSQL_datum ** datums
Definition: plpgsql.h:1072
PLpgSQL_function::resolve_option
PLpgSQL_resolve_option resolve_option
Definition: plpgsql.h:1008
ColumnRef::location
int location
Definition: parsenodes.h:236
HeapTupleData::t_data
HeapTupleHeader t_data
Definition: htup.h:68
plpgsql_HashTable
static HTAB * plpgsql_HashTable
Definition: pl_comp.c:61
parse_type.h
TypeCacheEntry::domainBaseType
Oid domainBaseType
Definition: typcache.h:105
error_context_stack
ErrorContextCallback * error_context_stack
Definition: elog.c:91
delete_function
static void delete_function(PLpgSQL_function *func)
Definition: pl_comp.c:2519
list_make1
#define list_make1(x1)
Definition: pg_list.h:227
plpgsql_HashEnt
struct plpgsql_hashent plpgsql_HashEnt
plpgsql_scanner_finish
void plpgsql_scanner_finish(void)
Definition: pl_scanner.c:613
HTAB
Definition: dynahash.c:208
PLpgSQL_expr::paramnos
Bitmapset * paramnos
Definition: plpgsql.h:223
PLpgSQL_datum
Definition: plpgsql.h:256
plpgsql_HashTableLookup
static PLpgSQL_function * plpgsql_HashTableLookup(PLpgSQL_func_hashkey *func_key)
Definition: pl_comp.c:2548
pfree
void pfree(void *pointer)
Definition: mcxt.c:1056
linitial
#define linitial(l)
Definition: pg_list.h:195
PLpgSQL_stmt_block::body
List * body
Definition: plpgsql.h:510
plpgsql_compile
PLpgSQL_function * plpgsql_compile(FunctionCallInfo fcinfo, bool forValidator)
Definition: pl_comp.c:135
plpgsql_check_syntax
bool plpgsql_check_syntax
Definition: pl_comp.c:50
ObjectIdGetDatum
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
ERROR
#define ERROR
Definition: elog.h:43
plpgsql_error_funcname
char * plpgsql_error_funcname
Definition: pl_comp.c:48
PLpgSQL_row::fieldnames
char ** fieldnames
Definition: plpgsql.h:363
PLpgSQL_function::cur_estate
struct PLpgSQL_execstate * cur_estate
Definition: plpgsql.h:1028
Param::paramcollid
Oid paramcollid
Definition: primnodes.h:266
PLpgSQL_func_hashkey
struct PLpgSQL_func_hashkey PLpgSQL_func_hashkey
PLpgSQL_recfield::nextfield
int nextfield
Definition: plpgsql.h:409
plpgsql_DumpExecTree
bool plpgsql_DumpExecTree
Definition: pl_comp.c:49
Param::location
int location
Definition: primnodes.h:267
plpgsql_parse_cwordtype
PLpgSQL_type * plpgsql_parse_cwordtype(List *idents)
Definition: pl_comp.c:1656
PLpgSQL_function::use_count
unsigned long use_count
Definition: plpgsql.h:1029
add_parameter_name
static void add_parameter_name(PLpgSQL_nsitem_type itemtype, int itemno, const char *name)
Definition: pl_comp.c:1004
PLpgSQL_variable
Definition: plpgsql.h:268
HeapTupleData::t_self
ItemPointerData t_self
Definition: htup.h:65
TupleDescInitEntryCollation
void TupleDescInitEntryCollation(TupleDesc desc, AttrNumber attributeNumber, Oid collationid)
Definition: tupdesc.c:769
PLpgSQL_function
Definition: plpgsql.h:981
plpgsql_extra_warnings
int plpgsql_extra_warnings
Definition: pl_handler.c:52
PLcword::idents
List * idents
Definition: plpgsql.h:1164
ALLOCSET_DEFAULT_SIZES
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:192
PLpgSQL_expr::ns
struct PLpgSQL_nsitem * ns
Definition: plpgsql.h:230
plpgsql_parser_setup
void plpgsql_parser_setup(struct ParseState *pstate, PLpgSQL_expr *expr)
Definition: pl_comp.c:1072
NoLock
#define NoLock
Definition: lockdefs.h:34
add_dummy_return
static void add_dummy_return(PLpgSQL_function *function)
Definition: pl_comp.c:1029
ParseState::p_paramref_hook
ParseParamRefHook p_paramref_hook
Definition: parse_node.h:220
buf
static char * buf
Definition: pg_test_fsync.c:67
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:955
plpgsql_param_ref
static Node * plpgsql_param_ref(ParseState *pstate, ParamRef *pref)
Definition: pl_comp.c:1143
PLpgSQL_func_hashkey::funcOid
Oid funcOid
Definition: plpgsql.h:940
datums_alloc
static int datums_alloc
Definition: pl_comp.c:43
lookup
Definition: zic.c:298
Form_pg_attribute
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:200
CurrentMemoryContext
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
PLpgSQL_function::fn_cxt
MemoryContext fn_cxt
Definition: plpgsql.h:990
plpgsql_ns_init
void plpgsql_ns_init(void)
Definition: pl_funcs.c:43
type_is_rowtype
bool type_is_rowtype(Oid typid)
Definition: lsyscache.c:2433
PLwdatum::idents
List * idents
Definition: plpgsql.h:1172
plpgsql_hashent::function
PLpgSQL_function * function
Definition: pl_comp.c:66
TupleDescInitEntry
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:603
htup_details.h
ereport
#define ereport(elevel, rest)
Definition: elog.h:141
A_Star
Definition: parsenodes.h:368
PLpgSQL_var::freeval
bool freeval
Definition: plpgsql.h:316
plpgsql_exec_get_datum_type_info
void plpgsql_exec_get_datum_type_info(PLpgSQL_execstate *estate, PLpgSQL_datum *datum, Oid *typeId, int32 *typMod, Oid *collation)
Definition: pl_exec.c:5609
TopMemoryContext
MemoryContext TopMemoryContext
Definition: mcxt.c:44
PLpgSQL_row::varnos
int * varnos
Definition: plpgsql.h:364
PLpgSQL_recfield::rectupledescid
uint64 rectupledescid
Definition: plpgsql.h:410
PLpgSQL_function::fn_input_collation
Oid fn_input_collation
Definition: plpgsql.h:988
lappend
List * lappend(List *list, void *datum)
Definition: list.c:322
PLpgSQL_type::typbyval
bool typbyval
Definition: plpgsql.h:205
TYPECACHE_DOMAIN_BASE_INFO
#define TYPECACHE_DOMAIN_BASE_INFO
Definition: typcache.h:140
PLpgSQL_nsitem::itemno
int itemno
Definition: plpgsql.h:450
PLpgSQL_rec::dno
int dno
Definition: plpgsql.h:373
PLpgSQL_func_hashkey::trigOid
Oid trigOid
Definition: plpgsql.h:952
WARNING
#define WARNING
Definition: elog.h:40
PLpgSQL_type::collation
Oid collation
Definition: plpgsql.h:207
SearchSysCache1
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1116
NameListToString
char * NameListToString(List *names)
Definition: namespace.c:3094
PLpgSQL_expr
Definition: plpgsql.h:219
HASH_BLOBS
#define HASH_BLOBS
Definition: hsearch.h:88
TextDatumGetCString
#define TextDatumGetCString(d)
Definition: builtins.h:84
PLpgSQL_type::typisarray
bool typisarray
Definition: plpgsql.h:208
palloc0
void * palloc0(Size size)
Definition: mcxt.c:980
plpgsql_HashTableDelete
static void plpgsql_HashTableDelete(PLpgSQL_function *function)
Definition: pl_comp.c:2582
PLpgSQL_func_hashkey::inputCollation
Oid inputCollation
Definition: plpgsql.h:959
hash_create
HTAB * hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
Definition: dynahash.c:316
Datum
uintptr_t Datum
Definition: postgres.h:367
plpgsql_IdentifierLookup
IdentifierLookup plpgsql_IdentifierLookup
Definition: pl_scanner.c:26
get_fn_expr_rettype
Oid get_fn_expr_rettype(FmgrInfo *flinfo)
Definition: fmgr.c:1780
ReleaseSysCache
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1164
PLword::quoted
bool quoted
Definition: plpgsql.h:1159
plpgsql_build_datatype
PLpgSQL_type * plpgsql_build_datatype(Oid typeOid, int32 typmod, Oid collation, TypeName *origtypname)
Definition: pl_comp.c:2047
FunctionCallInfoBaseData::flinfo
FmgrInfo * flinfo
Definition: fmgr.h:87
SysCacheGetAttr
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:1377
label
static char * label
Definition: pg_basebackup.c:120
PLpgSQL_recfield::dtype
PLpgSQL_datum_type dtype
Definition: plpgsql.h:403
get_rel_type_id
Oid get_rel_type_id(Oid relid)
Definition: lsyscache.c:1781
ParamRef::number
int number
Definition: parsenodes.h:245
HASHCTL::keysize
Size keysize
Definition: hsearch.h:72
TriggerData::tg_trigger
Trigger * tg_trigger
Definition: trigger.h:37
Form_pg_proc
FormData_pg_proc * Form_pg_proc
Definition: pg_proc.h:133
MemoryContextAllocZero
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:839
PLpgSQL_var::value
Datum value
Definition: plpgsql.h:314
lookup_type_cache
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:322
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:36
PLpgSQL_stmt_block
Definition: plpgsql.h:504
PLpgSQL_expr::func
struct PLpgSQL_function * func
Definition: plpgsql.h:227
makeTypeName
TypeName * makeTypeName(char *typnam)
Definition: makefuncs.c:442
FmgrInfo::fn_oid
Oid fn_oid
Definition: fmgr.h:59
PLpgSQL_recfield::recparentno
int recparentno
Definition: plpgsql.h:408
PLpgSQL_function::fn_is_trigger
PLpgSQL_trigtype fn_is_trigger
Definition: plpgsql.h:987
plpgsql_print_strict_params
bool plpgsql_print_strict_params
Definition: pl_handler.c:46
format_procedure
char * format_procedure(Oid procedure_oid)
Definition: regproc.c:323
Param::paramtypmod
int32 paramtypmod
Definition: primnodes.h:265
plpgsql_compile_error_callback
static void plpgsql_compile_error_callback(void *arg)
Definition: pl_comp.c:977
ParamRef::location
int location
Definition: parsenodes.h:246
plpgsql_variable_conflict
int plpgsql_variable_conflict
Definition: pl_handler.c:44
TypeCacheEntry::typtype
char typtype
Definition: typcache.h:41
makeNode
#define makeNode(_type_)
Definition: nodes.h:573
HeapTupleIsValid
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
CALLED_AS_TRIGGER
#define CALLED_AS_TRIGGER(fcinfo)
Definition: trigger.h:25
plpgsql_parse_cwordrowtype
PLpgSQL_type * plpgsql_parse_cwordrowtype(List *idents)
Definition: pl_comp.c:1804
Assert
#define Assert(condition)
Definition: c.h:739
PLpgSQL_row::nfields
int nfields
Definition: plpgsql.h:362
PLpgSQL_var::lineno
int lineno
Definition: plpgsql.h:295
plpgsql_parse_word
bool plpgsql_parse_word(char *word1, const char *yytxt, bool lookup, PLwdatum *wdatum, PLword *word)
Definition: pl_comp.c:1387
PLpgSQL_stmt_block::exceptions
PLpgSQL_exception_block * exceptions
Definition: plpgsql.h:513
ParseState::p_ref_hook_state
void * p_ref_hook_state
Definition: parse_node.h:222
FmgrInfo::fn_expr
fmNodePtr fn_expr
Definition: fmgr.h:66
Param::paramid
int paramid
Definition: primnodes.h:263
Size
size_t Size
Definition: c.h:467
resolve_column_ref
static Node * resolve_column_ref(ParseState *pstate, PLpgSQL_expr *expr, ColumnRef *cref, bool error_if_no_field)
Definition: pl_comp.c:1170
PLpgSQL_function::fn_signature
char * fn_signature
Definition: plpgsql.h:983
function_parse_error_transpose
bool function_parse_error_transpose(const char *prosrc)
Definition: pg_proc.c:992
PLwdatum::datum
PLpgSQL_datum * datum
Definition: plpgsql.h:1169
Form_pg_type
FormData_pg_type * Form_pg_type
Definition: pg_type.h:250
plpgsql_ns_push
void plpgsql_ns_push(const char *label, PLpgSQL_label_type label_type)
Definition: pl_funcs.c:54
list_length
static int list_length(const List *l)
Definition: pg_list.h:169
parser_errposition
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:110
PLpgSQL_type::typname
char * typname
Definition: plpgsql.h:201
plpgsql_parse_result
PLpgSQL_stmt_block * plpgsql_parse_result
Definition: pl_comp.c:41
plpgsql_build_variable
PLpgSQL_variable * plpgsql_build_variable(const char *refname, int lineno, PLpgSQL_type *dtype, bool add2namespace)
Definition: pl_comp.c:1843
exception_label_map
static const ExceptionLabelMap exception_label_map[]
Definition: pl_comp.c:81
MAXALIGN
#define MAXALIGN(LEN)
Definition: c.h:692
MemoryContextSetIdentifier
void MemoryContextSetIdentifier(MemoryContext context, const char *id)
Definition: mcxt.c:329
PLpgSQL_variable::refname
char * refname
Definition: plpgsql.h:272
HeapTupleHeaderGetRawXmin
#define HeapTupleHeaderGetRawXmin(tup)
Definition: htup_details.h:308
TypeCacheEntry::tupDesc_identifier
uint64 tupDesc_identifier
Definition: typcache.h:87
SearchSysCacheAttName
HeapTuple SearchSysCacheAttName(Oid relid, const char *attname)
Definition: syscache.c:1257
PLpgSQL_variable::dtype
PLpgSQL_datum_type dtype
Definition: plpgsql.h:270
FmgrInfo::fn_extra
void * fn_extra
Definition: fmgr.h:64
bms_add_member
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:736
ItemPointerEquals
bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
Definition: itemptr.c:29
repalloc
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1069
PLpgSQL_variable::isconst
bool isconst
Definition: plpgsql.h:274
name
const char * name
Definition: encode.c:521
word
static void word(struct vars *, int, struct state *, struct state *)
Definition: regcomp.c:1246
PLpgSQL_type::typtype
char typtype
Definition: plpgsql.h:206
plpgsql_add_initdatums
int plpgsql_add_initdatums(int **varnos)
Definition: pl_comp.c:2350
plpgsql_scanner_init
void plpgsql_scanner_init(const char *str)
Definition: pl_scanner.c:586
Form_pg_class
FormData_pg_class * Form_pg_class
Definition: pg_class.h:150
get_base_element_type
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2599
PLpgSQL_execstate
Definition: plpgsql.h:1035
PLpgSQL_condition
Definition: plpgsql.h:474
PLwdatum::quoted
bool quoted
Definition: plpgsql.h:1171
PLwdatum::ident
char * ident
Definition: plpgsql.h:1170
palloc
void * palloc(Size size)
Definition: mcxt.c:949
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:822
plpgsql_finish_datums
static void plpgsql_finish_datums(PLpgSQL_function *function)
Definition: pl_comp.c:2306
PLpgSQL_type::atttypmod
int32 atttypmod
Definition: plpgsql.h:209
MemoryContextAlloc
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:796
PLpgSQL_nsitem::itemtype
PLpgSQL_nsitem_type itemtype
Definition: plpgsql.h:444
elog
#define elog(elevel,...)
Definition: elog.h:228
plpgsql_parse_tripword
bool plpgsql_parse_tripword(char *word1, char *word2, char *word3, PLwdatum *wdatum, PLcword *cword)
Definition: pl_comp.c:1522
i
int i
Definition: preproc-comment.c:23
makeTypeNameFromNameList
TypeName * makeTypeNameFromNameList(List *names)
Definition: makefuncs.c:454
PLpgSQL_row::rowtupdesc
TupleDesc rowtupdesc
Definition: plpgsql.h:360
plpgsql_compile_tmp_cxt
MemoryContext plpgsql_compile_tmp_cxt
Definition: pl_comp.c:55
errcontext
#define errcontext
Definition: elog.h:183
NameStr
#define NameStr(name)
Definition: c.h:616
arg
void * arg
Definition: pg_backup_utils.c:27
datums_last
static int datums_last
Definition: pl_comp.c:46
lthird
#define lthird(l)
Definition: pg_list.h:205
PLpgSQL_variable::dno
int dno
Definition: plpgsql.h:271
ParseState::p_pre_columnref_hook
PreParseColumnRefHook p_pre_columnref_hook
Definition: parse_node.h:218
PLpgSQL_type::typlen
int16 typlen
Definition: plpgsql.h:204
PLpgSQL_function::fn_retset
bool fn_retset
Definition: plpgsql.h:997
PLpgSQL_rec::rectypeid
Oid rectypeid
Definition: plpgsql.h:388
plpgsql_parse_err_condition
PLpgSQL_condition * plpgsql_parse_err_condition(char *condname)
Definition: pl_comp.c:2221
build_row_from_vars
static PLpgSQL_row * build_row_from_vars(PLpgSQL_variable **vars, int numvars)
Definition: pl_comp.c:1933
vars
Definition: regcomp.c:224
List
Definition: pg_list.h:50
PLpgSQL_nsitem
Definition: plpgsql.h:442
snprintf
#define snprintf
Definition: port.h:192
TypeCacheEntry::tupDesc
TupleDesc tupDesc
Definition: typcache.h:86
PLpgSQL_stmt
Definition: plpgsql.h:458
plpgsql_post_column_ref
static Node * plpgsql_post_column_ref(ParseState *pstate, ColumnRef *cref, Node *var)
Definition: pl_comp.c:1099
PLpgSQL_recfield::fieldname
char * fieldname
Definition: plpgsql.h:407
PLpgSQL_rec::lineno
int lineno
Definition: plpgsql.h:375
Param::paramtype
Oid paramtype
Definition: primnodes.h:264
TYPECACHE_TUPDESC
#define TYPECACHE_TUPDESC
Definition: typcache.h:136
makeRangeVar
RangeVar * makeRangeVar(char *schemaname, char *relname, int location)
Definition: makefuncs.c:420
PLpgSQL_row::dtype
PLpgSQL_datum_type dtype
Definition: plpgsql.h:346
ColumnRef::fields
List * fields
Definition: parsenodes.h:235
PLpgSQL_rec::firstfield
int firstfield
Definition: plpgsql.h:390
plpgsql_curr_compile
PLpgSQL_function * plpgsql_curr_compile
Definition: pl_comp.c:52
PLpgSQL_nsitem_type
PLpgSQL_nsitem_type
Definition: plpgsql.h:41
make_datum_param
static Node * make_datum_param(PLpgSQL_expr *expr, int dno, int location)
Definition: pl_comp.c:1334
PLpgSQL_row::lineno
int lineno
Definition: plpgsql.h:349
PLpgSQL_var::isnull
bool isnull
Definition: plpgsql.h:315
PLpgSQL_type::typoid
Oid typoid
Definition: plpgsql.h:202