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