PostgreSQL Source Code  git master
refint.c
Go to the documentation of this file.
1 /*
2  * contrib/spi/refint.c
3  *
4  *
5  * refint.c -- set of functions to define referential integrity
6  * constraints using general triggers.
7  */
8 #include "postgres.h"
9 
10 #include <ctype.h>
11 
12 #include "commands/trigger.h"
13 #include "executor/spi.h"
14 #include "utils/builtins.h"
15 #include "utils/memutils.h"
16 #include "utils/rel.h"
17 
19 
20 typedef struct
21 {
22  char *ident;
23  int nplans;
25 } EPlan;
26 
27 static EPlan *FPlans = NULL;
28 static int nFPlans = 0;
29 static EPlan *PPlans = NULL;
30 static int nPPlans = 0;
31 
32 static EPlan *find_plan(char *ident, EPlan **eplan, int *nplans);
33 
34 /*
35  * check_primary_key () -- check that key in tuple being inserted/updated
36  * references existing tuple in "primary" table.
37  * Though it's called without args You have to specify referenced
38  * table/keys while creating trigger: key field names in triggered table,
39  * referenced table name, referenced key field names:
40  * EXECUTE PROCEDURE
41  * check_primary_key ('Fkey1', 'Fkey2', 'Ptable', 'Pkey1', 'Pkey2').
42  */
43 
45 
46 Datum
48 {
49  TriggerData *trigdata = (TriggerData *) fcinfo->context;
50  Trigger *trigger; /* to get trigger name */
51  int nargs; /* # of args specified in CREATE TRIGGER */
52  char **args; /* arguments: column names and table name */
53  int nkeys; /* # of key columns (= nargs / 2) */
54  Datum *kvals; /* key values */
55  char *relname; /* referenced relation name */
56  Relation rel; /* triggered relation */
57  HeapTuple tuple = NULL; /* tuple to return */
58  TupleDesc tupdesc; /* tuple description */
59  EPlan *plan; /* prepared plan */
60  Oid *argtypes = NULL; /* key types to prepare execution plan */
61  bool isnull; /* to know is some column NULL or not */
62  char ident[2 * NAMEDATALEN]; /* to identify myself */
63  int ret;
64  int i;
65 
66 #ifdef DEBUG_QUERY
67  elog(DEBUG4, "check_primary_key: Enter Function");
68 #endif
69 
70  /*
71  * Some checks first...
72  */
73 
74  /* Called by trigger manager ? */
75  if (!CALLED_AS_TRIGGER(fcinfo))
76  /* internal error */
77  elog(ERROR, "check_primary_key: not fired by trigger manager");
78 
79  /* Should be called for ROW trigger */
80  if (!TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
81  /* internal error */
82  elog(ERROR, "check_primary_key: must be fired for row");
83 
84  /* If INSERTion then must check Tuple to being inserted */
85  if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
86  tuple = trigdata->tg_trigtuple;
87 
88  /* Not should be called for DELETE */
89  else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
90  /* internal error */
91  elog(ERROR, "check_primary_key: cannot process DELETE events");
92 
93  /* If UPDATE, then must check new Tuple, not old one */
94  else
95  tuple = trigdata->tg_newtuple;
96 
97  trigger = trigdata->tg_trigger;
98  nargs = trigger->tgnargs;
99  args = trigger->tgargs;
100 
101  if (nargs % 2 != 1) /* odd number of arguments! */
102  /* internal error */
103  elog(ERROR, "check_primary_key: odd number of arguments should be specified");
104 
105  nkeys = nargs / 2;
106  relname = args[nkeys];
107  rel = trigdata->tg_relation;
108  tupdesc = rel->rd_att;
109 
110  /* Connect to SPI manager */
111  if ((ret = SPI_connect()) < 0)
112  /* internal error */
113  elog(ERROR, "check_primary_key: SPI_connect returned %d", ret);
114 
115  /*
116  * We use SPI plan preparation feature, so allocate space to place key
117  * values.
118  */
119  kvals = (Datum *) palloc(nkeys * sizeof(Datum));
120 
121  /*
122  * Construct ident string as TriggerName $ TriggeredRelationId and try to
123  * find prepared execution plan.
124  */
125  snprintf(ident, sizeof(ident), "%s$%u", trigger->tgname, rel->rd_id);
126  plan = find_plan(ident, &PPlans, &nPPlans);
127 
128  /* if there is no plan then allocate argtypes for preparation */
129  if (plan->nplans <= 0)
130  argtypes = (Oid *) palloc(nkeys * sizeof(Oid));
131 
132  /* For each column in key ... */
133  for (i = 0; i < nkeys; i++)
134  {
135  /* get index of column in tuple */
136  int fnumber = SPI_fnumber(tupdesc, args[i]);
137 
138  /* Bad guys may give us un-existing column in CREATE TRIGGER */
139  if (fnumber <= 0)
140  ereport(ERROR,
141  (errcode(ERRCODE_UNDEFINED_COLUMN),
142  errmsg("there is no attribute \"%s\" in relation \"%s\"",
143  args[i], SPI_getrelname(rel))));
144 
145  /* Well, get binary (in internal format) value of column */
146  kvals[i] = SPI_getbinval(tuple, tupdesc, fnumber, &isnull);
147 
148  /*
149  * If it's NULL then nothing to do! DON'T FORGET call SPI_finish ()!
150  * DON'T FORGET return tuple! Executor inserts tuple you're returning!
151  * If you return NULL then nothing will be inserted!
152  */
153  if (isnull)
154  {
155  SPI_finish();
156  return PointerGetDatum(tuple);
157  }
158 
159  if (plan->nplans <= 0) /* Get typeId of column */
160  argtypes[i] = SPI_gettypeid(tupdesc, fnumber);
161  }
162 
163  /*
164  * If we have to prepare plan ...
165  */
166  if (plan->nplans <= 0)
167  {
168  SPIPlanPtr pplan;
169  char sql[8192];
170 
171  /*
172  * Construct query: SELECT 1 FROM _referenced_relation_ WHERE Pkey1 =
173  * $1 [AND Pkey2 = $2 [...]]
174  */
175  snprintf(sql, sizeof(sql), "select 1 from %s where ", relname);
176  for (i = 0; i < nkeys; i++)
177  {
178  snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), "%s = $%d %s",
179  args[i + nkeys + 1], i + 1, (i < nkeys - 1) ? "and " : "");
180  }
181 
182  /* Prepare plan for query */
183  pplan = SPI_prepare(sql, nkeys, argtypes);
184  if (pplan == NULL)
185  /* internal error */
186  elog(ERROR, "check_primary_key: SPI_prepare returned %s", SPI_result_code_string(SPI_result));
187 
188  /*
189  * Remember that SPI_prepare places plan in current memory context -
190  * so, we have to save plan in TopMemoryContext for later use.
191  */
192  if (SPI_keepplan(pplan))
193  /* internal error */
194  elog(ERROR, "check_primary_key: SPI_keepplan failed");
196  sizeof(SPIPlanPtr));
197  *(plan->splan) = pplan;
198  plan->nplans = 1;
199  }
200 
201  /*
202  * Ok, execute prepared plan.
203  */
204  ret = SPI_execp(*(plan->splan), kvals, NULL, 1);
205  /* we have no NULLs - so we pass ^^^^ here */
206 
207  if (ret < 0)
208  /* internal error */
209  elog(ERROR, "check_primary_key: SPI_execp returned %d", ret);
210 
211  /*
212  * If there are no tuples returned by SELECT then ...
213  */
214  if (SPI_processed == 0)
215  ereport(ERROR,
216  (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
217  errmsg("tuple references non-existent key"),
218  errdetail("Trigger \"%s\" found tuple referencing non-existent key in \"%s\".", trigger->tgname, relname)));
219 
220  SPI_finish();
221 
222  return PointerGetDatum(tuple);
223 }
224 
225 /*
226  * check_foreign_key () -- check that key in tuple being deleted/updated
227  * is not referenced by tuples in "foreign" table(s).
228  * Though it's called without args You have to specify (while creating trigger):
229  * number of references, action to do if key referenced
230  * ('restrict' | 'setnull' | 'cascade'), key field names in triggered
231  * ("primary") table and referencing table(s)/keys:
232  * EXECUTE PROCEDURE
233  * check_foreign_key (2, 'restrict', 'Pkey1', 'Pkey2',
234  * 'Ftable1', 'Fkey11', 'Fkey12', 'Ftable2', 'Fkey21', 'Fkey22').
235  */
236 
238 
239 Datum
241 {
242  TriggerData *trigdata = (TriggerData *) fcinfo->context;
243  Trigger *trigger; /* to get trigger name */
244  int nargs; /* # of args specified in CREATE TRIGGER */
245  char **args; /* arguments: as described above */
246  char **args_temp;
247  int nrefs; /* number of references (== # of plans) */
248  char action; /* 'R'estrict | 'S'etnull | 'C'ascade */
249  int nkeys; /* # of key columns */
250  Datum *kvals; /* key values */
251  char *relname; /* referencing relation name */
252  Relation rel; /* triggered relation */
253  HeapTuple trigtuple = NULL; /* tuple to being changed */
254  HeapTuple newtuple = NULL; /* tuple to return */
255  TupleDesc tupdesc; /* tuple description */
256  EPlan *plan; /* prepared plan(s) */
257  Oid *argtypes = NULL; /* key types to prepare execution plan */
258  bool isnull; /* to know is some column NULL or not */
259  bool isequal = true; /* are keys in both tuples equal (in UPDATE) */
260  char ident[2 * NAMEDATALEN]; /* to identify myself */
261  int is_update = 0;
262  int ret;
263  int i,
264  r;
265 
266 #ifdef DEBUG_QUERY
267  elog(DEBUG4, "check_foreign_key: Enter Function");
268 #endif
269 
270  /*
271  * Some checks first...
272  */
273 
274  /* Called by trigger manager ? */
275  if (!CALLED_AS_TRIGGER(fcinfo))
276  /* internal error */
277  elog(ERROR, "check_foreign_key: not fired by trigger manager");
278 
279  /* Should be called for ROW trigger */
280  if (!TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
281  /* internal error */
282  elog(ERROR, "check_foreign_key: must be fired for row");
283 
284  /* Not should be called for INSERT */
285  if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
286  /* internal error */
287  elog(ERROR, "check_foreign_key: cannot process INSERT events");
288 
289  /* Have to check tg_trigtuple - tuple being deleted */
290  trigtuple = trigdata->tg_trigtuple;
291 
292  /*
293  * But if this is UPDATE then we have to return tg_newtuple. Also, if key
294  * in tg_newtuple is the same as in tg_trigtuple then nothing to do.
295  */
296  is_update = 0;
297  if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
298  {
299  newtuple = trigdata->tg_newtuple;
300  is_update = 1;
301  }
302  trigger = trigdata->tg_trigger;
303  nargs = trigger->tgnargs;
304  args = trigger->tgargs;
305 
306  if (nargs < 5) /* nrefs, action, key, Relation, key - at
307  * least */
308  /* internal error */
309  elog(ERROR, "check_foreign_key: too short %d (< 5) list of arguments", nargs);
310 
311  nrefs = pg_strtoint32(args[0]);
312  if (nrefs < 1)
313  /* internal error */
314  elog(ERROR, "check_foreign_key: %d (< 1) number of references specified", nrefs);
315  action = tolower((unsigned char) *(args[1]));
316  if (action != 'r' && action != 'c' && action != 's')
317  /* internal error */
318  elog(ERROR, "check_foreign_key: invalid action %s", args[1]);
319  nargs -= 2;
320  args += 2;
321  nkeys = (nargs - nrefs) / (nrefs + 1);
322  if (nkeys <= 0 || nargs != (nrefs + nkeys * (nrefs + 1)))
323  /* internal error */
324  elog(ERROR, "check_foreign_key: invalid number of arguments %d for %d references",
325  nargs + 2, nrefs);
326 
327  rel = trigdata->tg_relation;
328  tupdesc = rel->rd_att;
329 
330  /* Connect to SPI manager */
331  if ((ret = SPI_connect()) < 0)
332  /* internal error */
333  elog(ERROR, "check_foreign_key: SPI_connect returned %d", ret);
334 
335  /*
336  * We use SPI plan preparation feature, so allocate space to place key
337  * values.
338  */
339  kvals = (Datum *) palloc(nkeys * sizeof(Datum));
340 
341  /*
342  * Construct ident string as TriggerName $ TriggeredRelationId and try to
343  * find prepared execution plan(s).
344  */
345  snprintf(ident, sizeof(ident), "%s$%u", trigger->tgname, rel->rd_id);
346  plan = find_plan(ident, &FPlans, &nFPlans);
347 
348  /* if there is no plan(s) then allocate argtypes for preparation */
349  if (plan->nplans <= 0)
350  argtypes = (Oid *) palloc(nkeys * sizeof(Oid));
351 
352  /*
353  * else - check that we have exactly nrefs plan(s) ready
354  */
355  else if (plan->nplans != nrefs)
356  /* internal error */
357  elog(ERROR, "%s: check_foreign_key: # of plans changed in meantime",
358  trigger->tgname);
359 
360  /* For each column in key ... */
361  for (i = 0; i < nkeys; i++)
362  {
363  /* get index of column in tuple */
364  int fnumber = SPI_fnumber(tupdesc, args[i]);
365 
366  /* Bad guys may give us un-existing column in CREATE TRIGGER */
367  if (fnumber <= 0)
368  ereport(ERROR,
369  (errcode(ERRCODE_UNDEFINED_COLUMN),
370  errmsg("there is no attribute \"%s\" in relation \"%s\"",
371  args[i], SPI_getrelname(rel))));
372 
373  /* Well, get binary (in internal format) value of column */
374  kvals[i] = SPI_getbinval(trigtuple, tupdesc, fnumber, &isnull);
375 
376  /*
377  * If it's NULL then nothing to do! DON'T FORGET call SPI_finish ()!
378  * DON'T FORGET return tuple! Executor inserts tuple you're returning!
379  * If you return NULL then nothing will be inserted!
380  */
381  if (isnull)
382  {
383  SPI_finish();
384  return PointerGetDatum((newtuple == NULL) ? trigtuple : newtuple);
385  }
386 
387  /*
388  * If UPDATE then get column value from new tuple being inserted and
389  * compare is this the same as old one. For the moment we use string
390  * presentation of values...
391  */
392  if (newtuple != NULL)
393  {
394  char *oldval = SPI_getvalue(trigtuple, tupdesc, fnumber);
395  char *newval;
396 
397  /* this shouldn't happen! SPI_ERROR_NOOUTFUNC ? */
398  if (oldval == NULL)
399  /* internal error */
400  elog(ERROR, "check_foreign_key: SPI_getvalue returned %s", SPI_result_code_string(SPI_result));
401  newval = SPI_getvalue(newtuple, tupdesc, fnumber);
402  if (newval == NULL || strcmp(oldval, newval) != 0)
403  isequal = false;
404  }
405 
406  if (plan->nplans <= 0) /* Get typeId of column */
407  argtypes[i] = SPI_gettypeid(tupdesc, fnumber);
408  }
409  args_temp = args;
410  nargs -= nkeys;
411  args += nkeys;
412 
413  /*
414  * If we have to prepare plans ...
415  */
416  if (plan->nplans <= 0)
417  {
418  SPIPlanPtr pplan;
419  char sql[8192];
420  char **args2 = args;
421 
423  nrefs * sizeof(SPIPlanPtr));
424 
425  for (r = 0; r < nrefs; r++)
426  {
427  relname = args2[0];
428 
429  /*---------
430  * For 'R'estrict action we construct SELECT query:
431  *
432  * SELECT 1
433  * FROM _referencing_relation_
434  * WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]]
435  *
436  * to check is tuple referenced or not.
437  *---------
438  */
439  if (action == 'r')
440 
441  snprintf(sql, sizeof(sql), "select 1 from %s where ", relname);
442 
443  /*---------
444  * For 'C'ascade action we construct DELETE query
445  *
446  * DELETE
447  * FROM _referencing_relation_
448  * WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]]
449  *
450  * to delete all referencing tuples.
451  *---------
452  */
453 
454  /*
455  * Max : Cascade with UPDATE query i create update query that
456  * updates new key values in referenced tables
457  */
458 
459 
460  else if (action == 'c')
461  {
462  if (is_update == 1)
463  {
464  int fn;
465  char *nv;
466  int k;
467 
468  snprintf(sql, sizeof(sql), "update %s set ", relname);
469  for (k = 1; k <= nkeys; k++)
470  {
471  int is_char_type = 0;
472  char *type;
473 
474  fn = SPI_fnumber(tupdesc, args_temp[k - 1]);
475  Assert(fn > 0); /* already checked above */
476  nv = SPI_getvalue(newtuple, tupdesc, fn);
477  type = SPI_gettype(tupdesc, fn);
478 
479  if (strcmp(type, "text") == 0 ||
480  strcmp(type, "varchar") == 0 ||
481  strcmp(type, "char") == 0 ||
482  strcmp(type, "bpchar") == 0 ||
483  strcmp(type, "date") == 0 ||
484  strcmp(type, "timestamp") == 0)
485  is_char_type = 1;
486 #ifdef DEBUG_QUERY
487  elog(DEBUG4, "check_foreign_key Debug value %s type %s %d",
488  nv, type, is_char_type);
489 #endif
490 
491  /*
492  * is_char_type =1 i set ' ' for define a new value
493  */
494  snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql),
495  " %s = %s%s%s %s ",
496  args2[k], (is_char_type > 0) ? "'" : "",
497  nv, (is_char_type > 0) ? "'" : "", (k < nkeys) ? ", " : "");
498  }
499  strcat(sql, " where ");
500 
501  }
502  else
503  /* DELETE */
504  snprintf(sql, sizeof(sql), "delete from %s where ", relname);
505 
506  }
507 
508  /*
509  * For 'S'etnull action we construct UPDATE query - UPDATE
510  * _referencing_relation_ SET Fkey1 null [, Fkey2 null [...]]
511  * WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]] - to set key columns in
512  * all referencing tuples to NULL.
513  */
514  else if (action == 's')
515  {
516  snprintf(sql, sizeof(sql), "update %s set ", relname);
517  for (i = 1; i <= nkeys; i++)
518  {
519  snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql),
520  "%s = null%s",
521  args2[i], (i < nkeys) ? ", " : "");
522  }
523  strcat(sql, " where ");
524  }
525 
526  /* Construct WHERE qual */
527  for (i = 1; i <= nkeys; i++)
528  {
529  snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), "%s = $%d %s",
530  args2[i], i, (i < nkeys) ? "and " : "");
531  }
532 
533  /* Prepare plan for query */
534  pplan = SPI_prepare(sql, nkeys, argtypes);
535  if (pplan == NULL)
536  /* internal error */
537  elog(ERROR, "check_foreign_key: SPI_prepare returned %s", SPI_result_code_string(SPI_result));
538 
539  /*
540  * Remember that SPI_prepare places plan in current memory context
541  * - so, we have to save plan in Top memory context for later use.
542  */
543  if (SPI_keepplan(pplan))
544  /* internal error */
545  elog(ERROR, "check_foreign_key: SPI_keepplan failed");
546 
547  plan->splan[r] = pplan;
548 
549  args2 += nkeys + 1; /* to the next relation */
550  }
551  plan->nplans = nrefs;
552 #ifdef DEBUG_QUERY
553  elog(DEBUG4, "check_foreign_key Debug Query is : %s ", sql);
554 #endif
555  }
556 
557  /*
558  * If UPDATE and key is not changed ...
559  */
560  if (newtuple != NULL && isequal)
561  {
562  SPI_finish();
563  return PointerGetDatum(newtuple);
564  }
565 
566  /*
567  * Ok, execute prepared plan(s).
568  */
569  for (r = 0; r < nrefs; r++)
570  {
571  /*
572  * For 'R'estrict we may to execute plan for one tuple only, for other
573  * actions - for all tuples.
574  */
575  int tcount = (action == 'r') ? 1 : 0;
576 
577  relname = args[0];
578 
579  snprintf(ident, sizeof(ident), "%s$%u", trigger->tgname, rel->rd_id);
580  plan = find_plan(ident, &FPlans, &nFPlans);
581  ret = SPI_execp(plan->splan[r], kvals, NULL, tcount);
582  /* we have no NULLs - so we pass ^^^^ here */
583 
584  if (ret < 0)
585  ereport(ERROR,
586  (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
587  errmsg("SPI_execp returned %d", ret)));
588 
589  /* If action is 'R'estrict ... */
590  if (action == 'r')
591  {
592  /* If there is tuple returned by SELECT then ... */
593  if (SPI_processed > 0)
594  ereport(ERROR,
595  (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
596  errmsg("\"%s\": tuple is referenced in \"%s\"",
597  trigger->tgname, relname)));
598  }
599  else
600  {
601 #ifdef REFINT_VERBOSE
602  elog(NOTICE, "%s: " UINT64_FORMAT " tuple(s) of %s are %s",
603  trigger->tgname, SPI_processed, relname,
604  (action == 'c') ? "deleted" : "set to null");
605 #endif
606  }
607  args += nkeys + 1; /* to the next relation */
608  }
609 
610  SPI_finish();
611 
612  return PointerGetDatum((newtuple == NULL) ? trigtuple : newtuple);
613 }
614 
615 static EPlan *
616 find_plan(char *ident, EPlan **eplan, int *nplans)
617 {
618  EPlan *newp;
619  int i;
620  MemoryContext oldcontext;
621 
622  /*
623  * All allocations done for the plans need to happen in a session-safe
624  * context.
625  */
627 
628  if (*nplans > 0)
629  {
630  for (i = 0; i < *nplans; i++)
631  {
632  if (strcmp((*eplan)[i].ident, ident) == 0)
633  break;
634  }
635  if (i != *nplans)
636  {
637  MemoryContextSwitchTo(oldcontext);
638  return (*eplan + i);
639  }
640  *eplan = (EPlan *) repalloc(*eplan, (i + 1) * sizeof(EPlan));
641  newp = *eplan + i;
642  }
643  else
644  {
645  newp = *eplan = (EPlan *) palloc(sizeof(EPlan));
646  (*nplans) = i = 0;
647  }
648 
649  newp->ident = pstrdup(ident);
650  newp->nplans = 0;
651  newp->splan = NULL;
652  (*nplans)++;
653 
654  MemoryContextSwitchTo(oldcontext);
655  return newp;
656 }
int SPI_fnumber(TupleDesc tupdesc, const char *fname)
Definition: spi.c:951
Oid SPI_gettypeid(TupleDesc tupdesc, int fnumber)
Definition: spi.c:1084
static int nFPlans
Definition: refint.c:28
int SPI_connect(void)
Definition: spi.c:89
#define PointerGetDatum(X)
Definition: postgres.h:556
char * pstrdup(const char *in)
Definition: mcxt.c:1186
SPIPlanPtr SPI_prepare(const char *src, int nargs, Oid *argtypes)
Definition: spi.c:674
int SPI_finish(void)
Definition: spi.c:176
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
Datum check_foreign_key(PG_FUNCTION_ARGS)
Definition: refint.c:240
int errcode(int sqlerrcode)
Definition: elog.c:610
PG_FUNCTION_INFO_V1(check_primary_key)
NameData relname
Definition: pg_class.h:38
unsigned int Oid
Definition: postgres_ext.h:31
#define DEBUG4
Definition: elog.h:22
Datum check_primary_key(PG_FUNCTION_ARGS)
Definition: refint.c:47
uint64 SPI_processed
Definition: spi.c:45
HeapTuple tg_trigtuple
Definition: trigger.h:35
char * SPI_gettype(TupleDesc tupdesc, int fnumber)
Definition: spi.c:1044
char * SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber)
Definition: spi.c:996
#define NAMEDATALEN
int SPI_result
Definition: spi.c:47
#define ERROR
Definition: elog.h:43
Datum SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull)
Definition: spi.c:1028
const char * SPI_result_code_string(int code)
Definition: spi.c:1699
int SPI_keepplan(SPIPlanPtr plan)
Definition: spi.c:752
int nplans
Definition: refint.c:23
int errdetail(const char *fmt,...)
Definition: elog.c:957
static EPlan * find_plan(char *ident, EPlan **eplan, int *nplans)
Definition: refint.c:616
MemoryContext TopMemoryContext
Definition: mcxt.c:44
SPIPlanPtr * splan
Definition: refint.c:24
#define TRIGGER_FIRED_BY_DELETE(event)
Definition: trigger.h:120
uintptr_t Datum
Definition: postgres.h:367
Trigger * tg_trigger
Definition: trigger.h:37
TupleDesc rd_att
Definition: rel.h:90
HeapTuple tg_newtuple
Definition: trigger.h:36
char * SPI_getrelname(Relation rel)
Definition: spi.c:1102
#define ereport(elevel,...)
Definition: elog.h:144
static void * fn(void *arg)
#define NOTICE
Definition: elog.h:37
static EPlan * PPlans
Definition: refint.c:29
#define CALLED_AS_TRIGGER(fcinfo)
Definition: trigger.h:25
#define Assert(condition)
Definition: c.h:738
TriggerEvent tg_event
Definition: trigger.h:33
Definition: refint.c:20
#define newval
PG_MODULE_MAGIC
Definition: refint.c:18
char * ident
Definition: refint.c:22
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1069
int32 pg_strtoint32(const char *s)
Definition: numutils.c:261
#define TRIGGER_FIRED_BY_INSERT(event)
Definition: trigger.h:117
void * palloc(Size size)
Definition: mcxt.c:949
int errmsg(const char *fmt,...)
Definition: elog.c:824
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:796
#define elog(elevel,...)
Definition: elog.h:214
int i
int SPI_execp(SPIPlanPtr plan, Datum *Values, const char *Nulls, long tcount)
Definition: spi.c:558
int16 tgnargs
Definition: reltrigger.h:38
#define PG_FUNCTION_ARGS
Definition: fmgr.h:188
static EPlan * FPlans
Definition: refint.c:27
#define TRIGGER_FIRED_FOR_ROW(event)
Definition: trigger.h:129
#define snprintf
Definition: port.h:192
#define TRIGGER_FIRED_BY_UPDATE(event)
Definition: trigger.h:123
#define UINT64_FORMAT
Definition: c.h:410
static int nPPlans
Definition: refint.c:30
Relation tg_relation
Definition: trigger.h:34