Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * ri_triggers.c
4 : *
5 : * Generic trigger procedures for referential integrity constraint
6 : * checks.
7 : *
8 : * Note about memory management: the private hashtables kept here live
9 : * across query and transaction boundaries, in fact they live as long as
10 : * the backend does. This works because the hashtable structures
11 : * themselves are allocated by dynahash.c in its permanent DynaHashCxt,
12 : * and the SPI plans they point to are saved using SPI_keepplan().
13 : * There is not currently any provision for throwing away a no-longer-needed
14 : * plan --- consider improving this someday.
15 : *
16 : *
17 : * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
18 : *
19 : * src/backend/utils/adt/ri_triggers.c
20 : *
21 : *-------------------------------------------------------------------------
22 : */
23 :
24 : #include "postgres.h"
25 :
26 : #include "access/htup_details.h"
27 : #include "access/sysattr.h"
28 : #include "access/table.h"
29 : #include "access/tableam.h"
30 : #include "access/xact.h"
31 : #include "catalog/pg_collation.h"
32 : #include "catalog/pg_constraint.h"
33 : #include "catalog/pg_operator.h"
34 : #include "catalog/pg_type.h"
35 : #include "commands/trigger.h"
36 : #include "executor/executor.h"
37 : #include "executor/spi.h"
38 : #include "lib/ilist.h"
39 : #include "miscadmin.h"
40 : #include "parser/parse_coerce.h"
41 : #include "parser/parse_relation.h"
42 : #include "storage/bufmgr.h"
43 : #include "utils/acl.h"
44 : #include "utils/builtins.h"
45 : #include "utils/datum.h"
46 : #include "utils/fmgroids.h"
47 : #include "utils/guc.h"
48 : #include "utils/inval.h"
49 : #include "utils/lsyscache.h"
50 : #include "utils/memutils.h"
51 : #include "utils/rel.h"
52 : #include "utils/rls.h"
53 : #include "utils/ruleutils.h"
54 : #include "utils/snapmgr.h"
55 : #include "utils/syscache.h"
56 :
57 : /*
58 : * Local definitions
59 : */
60 :
61 : #define RI_MAX_NUMKEYS INDEX_MAX_KEYS
62 :
63 : #define RI_INIT_CONSTRAINTHASHSIZE 64
64 : #define RI_INIT_QUERYHASHSIZE (RI_INIT_CONSTRAINTHASHSIZE * 4)
65 :
66 : #define RI_KEYS_ALL_NULL 0
67 : #define RI_KEYS_SOME_NULL 1
68 : #define RI_KEYS_NONE_NULL 2
69 :
70 : /* RI query type codes */
71 : /* these queries are executed against the PK (referenced) table: */
72 : #define RI_PLAN_CHECK_LOOKUPPK 1
73 : #define RI_PLAN_CHECK_LOOKUPPK_FROM_PK 2
74 : #define RI_PLAN_LAST_ON_PK RI_PLAN_CHECK_LOOKUPPK_FROM_PK
75 : /* these queries are executed against the FK (referencing) table: */
76 : #define RI_PLAN_CASCADE_DEL_DODELETE 3
77 : #define RI_PLAN_CASCADE_UPD_DOUPDATE 4
78 : #define RI_PLAN_RESTRICT_CHECKREF 5
79 : #define RI_PLAN_SETNULL_DOUPDATE 6
80 : #define RI_PLAN_SETDEFAULT_DOUPDATE 7
81 :
82 : #define MAX_QUOTED_NAME_LEN (NAMEDATALEN*2+3)
83 : #define MAX_QUOTED_REL_NAME_LEN (MAX_QUOTED_NAME_LEN*2)
84 :
85 : #define RIAttName(rel, attnum) NameStr(*attnumAttName(rel, attnum))
86 : #define RIAttType(rel, attnum) attnumTypeId(rel, attnum)
87 : #define RIAttCollation(rel, attnum) attnumCollationId(rel, attnum)
88 :
89 : #define RI_TRIGTYPE_INSERT 1
90 : #define RI_TRIGTYPE_UPDATE 2
91 : #define RI_TRIGTYPE_DELETE 3
92 :
93 :
94 : /*
95 : * RI_ConstraintInfo
96 : *
97 : * Information extracted from an FK pg_constraint entry. This is cached in
98 : * ri_constraint_cache.
99 : */
100 : typedef struct RI_ConstraintInfo
101 : {
102 : Oid constraint_id; /* OID of pg_constraint entry (hash key) */
103 : bool valid; /* successfully initialized? */
104 : uint32 oidHashValue; /* hash value of pg_constraint OID */
105 : NameData conname; /* name of the FK constraint */
106 : Oid pk_relid; /* referenced relation */
107 : Oid fk_relid; /* referencing relation */
108 : char confupdtype; /* foreign key's ON UPDATE action */
109 : char confdeltype; /* foreign key's ON DELETE action */
110 : char confmatchtype; /* foreign key's match type */
111 : int nkeys; /* number of key columns */
112 : int16 pk_attnums[RI_MAX_NUMKEYS]; /* attnums of referenced cols */
113 : int16 fk_attnums[RI_MAX_NUMKEYS]; /* attnums of referencing cols */
114 : Oid pf_eq_oprs[RI_MAX_NUMKEYS]; /* equality operators (PK = FK) */
115 : Oid pp_eq_oprs[RI_MAX_NUMKEYS]; /* equality operators (PK = PK) */
116 : Oid ff_eq_oprs[RI_MAX_NUMKEYS]; /* equality operators (FK = FK) */
117 : dlist_node valid_link; /* Link in list of valid entries */
118 : } RI_ConstraintInfo;
119 :
120 : /*
121 : * RI_QueryKey
122 : *
123 : * The key identifying a prepared SPI plan in our query hashtable
124 : */
125 : typedef struct RI_QueryKey
126 : {
127 : Oid constr_id; /* OID of pg_constraint entry */
128 : int32 constr_queryno; /* query type ID, see RI_PLAN_XXX above */
129 : } RI_QueryKey;
130 :
131 : /*
132 : * RI_QueryHashEntry
133 : */
134 : typedef struct RI_QueryHashEntry
135 : {
136 : RI_QueryKey key;
137 : SPIPlanPtr plan;
138 : } RI_QueryHashEntry;
139 :
140 : /*
141 : * RI_CompareKey
142 : *
143 : * The key identifying an entry showing how to compare two values
144 : */
145 : typedef struct RI_CompareKey
146 : {
147 : Oid eq_opr; /* the equality operator to apply */
148 : Oid typeid; /* the data type to apply it to */
149 : } RI_CompareKey;
150 :
151 : /*
152 : * RI_CompareHashEntry
153 : */
154 : typedef struct RI_CompareHashEntry
155 : {
156 : RI_CompareKey key;
157 : bool valid; /* successfully initialized? */
158 : FmgrInfo eq_opr_finfo; /* call info for equality fn */
159 : FmgrInfo cast_func_finfo; /* in case we must coerce input */
160 : } RI_CompareHashEntry;
161 :
162 :
163 : /*
164 : * Local data
165 : */
166 : static HTAB *ri_constraint_cache = NULL;
167 : static HTAB *ri_query_cache = NULL;
168 : static HTAB *ri_compare_cache = NULL;
169 : static dlist_head ri_constraint_cache_valid_list;
170 : static int ri_constraint_cache_valid_count = 0;
171 :
172 :
173 : /*
174 : * Local function prototypes
175 : */
176 : static bool ri_Check_Pk_Match(Relation pk_rel, Relation fk_rel,
177 : TupleTableSlot *oldslot,
178 : const RI_ConstraintInfo *riinfo);
179 : static Datum ri_restrict(TriggerData *trigdata, bool is_no_action);
180 : static Datum ri_set(TriggerData *trigdata, bool is_set_null);
181 : static void quoteOneName(char *buffer, const char *name);
182 : static void quoteRelationName(char *buffer, Relation rel);
183 : static void ri_GenerateQual(StringInfo buf,
184 : const char *sep,
185 : const char *leftop, Oid leftoptype,
186 : Oid opoid,
187 : const char *rightop, Oid rightoptype);
188 : static void ri_GenerateQualCollation(StringInfo buf, Oid collation);
189 : static int ri_NullCheck(TupleDesc tupdesc, TupleTableSlot *slot,
190 : const RI_ConstraintInfo *riinfo, bool rel_is_pk);
191 : static void ri_BuildQueryKey(RI_QueryKey *key,
192 : const RI_ConstraintInfo *riinfo,
193 : int32 constr_queryno);
194 : static bool ri_KeysEqual(Relation rel, TupleTableSlot *oldslot, TupleTableSlot *newslot,
195 : const RI_ConstraintInfo *riinfo, bool rel_is_pk);
196 : static bool ri_AttributesEqual(Oid eq_opr, Oid typeid,
197 : Datum oldvalue, Datum newvalue);
198 :
199 : static void ri_InitHashTables(void);
200 : static void InvalidateConstraintCacheCallBack(Datum arg, int cacheid, uint32 hashvalue);
201 : static SPIPlanPtr ri_FetchPreparedPlan(RI_QueryKey *key);
202 : static void ri_HashPreparedPlan(RI_QueryKey *key, SPIPlanPtr plan);
203 : static RI_CompareHashEntry *ri_HashCompareOp(Oid eq_opr, Oid typeid);
204 :
205 : static void ri_CheckTrigger(FunctionCallInfo fcinfo, const char *funcname,
206 : int tgkind);
207 : static const RI_ConstraintInfo *ri_FetchConstraintInfo(Trigger *trigger,
208 : Relation trig_rel, bool rel_is_pk);
209 : static const RI_ConstraintInfo *ri_LoadConstraintInfo(Oid constraintOid);
210 : static SPIPlanPtr ri_PlanCheck(const char *querystr, int nargs, Oid *argtypes,
211 : RI_QueryKey *qkey, Relation fk_rel, Relation pk_rel);
212 : static bool ri_PerformCheck(const RI_ConstraintInfo *riinfo,
213 : RI_QueryKey *qkey, SPIPlanPtr qplan,
214 : Relation fk_rel, Relation pk_rel,
215 : TupleTableSlot *oldslot, TupleTableSlot *newslot,
216 : bool detectNewRows, int expect_OK);
217 : static void ri_ExtractValues(Relation rel, TupleTableSlot *slot,
218 : const RI_ConstraintInfo *riinfo, bool rel_is_pk,
219 : Datum *vals, char *nulls);
220 : static void ri_ReportViolation(const RI_ConstraintInfo *riinfo,
221 : Relation pk_rel, Relation fk_rel,
222 : TupleTableSlot *violatorslot, TupleDesc tupdesc,
223 : int queryno, bool partgone) pg_attribute_noreturn();
224 :
225 :
226 : /*
227 : * RI_FKey_check -
228 : *
229 : * Check foreign key existence (combined for INSERT and UPDATE).
230 : */
231 : static Datum
232 2790 : RI_FKey_check(TriggerData *trigdata)
233 : {
234 : const RI_ConstraintInfo *riinfo;
235 : Relation fk_rel;
236 : Relation pk_rel;
237 : TupleTableSlot *newslot;
238 : RI_QueryKey qkey;
239 : SPIPlanPtr qplan;
240 :
241 2790 : riinfo = ri_FetchConstraintInfo(trigdata->tg_trigger,
242 : trigdata->tg_relation, false);
243 :
244 2790 : if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
245 214 : newslot = trigdata->tg_newslot;
246 : else
247 2576 : newslot = trigdata->tg_trigslot;
248 :
249 : /*
250 : * We should not even consider checking the row if it is no longer valid,
251 : * since it was either deleted (so the deferred check should be skipped)
252 : * or updated (in which case only the latest version of the row should be
253 : * checked). Test its liveness according to SnapshotSelf. We need pin
254 : * and lock on the buffer to call HeapTupleSatisfiesVisibility. Caller
255 : * should be holding pin, but not lock.
256 : */
257 2790 : if (!table_tuple_satisfies_snapshot(trigdata->tg_relation, newslot, SnapshotSelf))
258 40 : return PointerGetDatum(NULL);
259 :
260 : /*
261 : * Get the relation descriptors of the FK and PK tables.
262 : *
263 : * pk_rel is opened in RowShareLock mode since that's what our eventual
264 : * SELECT FOR KEY SHARE will get on it.
265 : */
266 2750 : fk_rel = trigdata->tg_relation;
267 2750 : pk_rel = table_open(riinfo->pk_relid, RowShareLock);
268 :
269 2750 : switch (ri_NullCheck(RelationGetDescr(fk_rel), newslot, riinfo, false))
270 : {
271 92 : case RI_KEYS_ALL_NULL:
272 :
273 : /*
274 : * No further check needed - an all-NULL key passes every type of
275 : * foreign key constraint.
276 : */
277 92 : table_close(pk_rel, RowShareLock);
278 92 : return PointerGetDatum(NULL);
279 :
280 92 : case RI_KEYS_SOME_NULL:
281 :
282 : /*
283 : * This is the only case that differs between the three kinds of
284 : * MATCH.
285 : */
286 92 : switch (riinfo->confmatchtype)
287 : {
288 24 : case FKCONSTR_MATCH_FULL:
289 :
290 : /*
291 : * Not allowed - MATCH FULL says either all or none of the
292 : * attributes can be NULLs
293 : */
294 24 : ereport(ERROR,
295 : (errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
296 : errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
297 : RelationGetRelationName(fk_rel),
298 : NameStr(riinfo->conname)),
299 : errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
300 : errtableconstraint(fk_rel,
301 : NameStr(riinfo->conname))));
302 : table_close(pk_rel, RowShareLock);
303 : return PointerGetDatum(NULL);
304 :
305 68 : case FKCONSTR_MATCH_SIMPLE:
306 :
307 : /*
308 : * MATCH SIMPLE - if ANY column is null, the key passes
309 : * the constraint.
310 : */
311 68 : table_close(pk_rel, RowShareLock);
312 68 : return PointerGetDatum(NULL);
313 :
314 : #ifdef NOT_USED
315 : case FKCONSTR_MATCH_PARTIAL:
316 :
317 : /*
318 : * MATCH PARTIAL - all non-null columns must match. (not
319 : * implemented, can be done by modifying the query below
320 : * to only include non-null columns, or by writing a
321 : * special version here)
322 : */
323 : break;
324 : #endif
325 : }
326 :
327 : case RI_KEYS_NONE_NULL:
328 :
329 : /*
330 : * Have a full qualified key - continue below for all three kinds
331 : * of MATCH.
332 : */
333 2566 : break;
334 : }
335 :
336 2566 : if (SPI_connect() != SPI_OK_CONNECT)
337 0 : elog(ERROR, "SPI_connect failed");
338 :
339 : /* Fetch or prepare a saved plan for the real check */
340 2566 : ri_BuildQueryKey(&qkey, riinfo, RI_PLAN_CHECK_LOOKUPPK);
341 :
342 2566 : if ((qplan = ri_FetchPreparedPlan(&qkey)) == NULL)
343 : {
344 : StringInfoData querybuf;
345 : char pkrelname[MAX_QUOTED_REL_NAME_LEN];
346 : char attname[MAX_QUOTED_NAME_LEN];
347 : char paramname[16];
348 : const char *querysep;
349 : Oid queryoids[RI_MAX_NUMKEYS];
350 : const char *pk_only;
351 :
352 : /* ----------
353 : * The query string built is
354 : * SELECT 1 FROM [ONLY] <pktable> x WHERE pkatt1 = $1 [AND ...]
355 : * FOR KEY SHARE OF x
356 : * The type id's for the $ parameters are those of the
357 : * corresponding FK attributes.
358 : * ----------
359 : */
360 1622 : initStringInfo(&querybuf);
361 3244 : pk_only = pk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
362 1622 : "" : "ONLY ";
363 1622 : quoteRelationName(pkrelname, pk_rel);
364 1622 : appendStringInfo(&querybuf, "SELECT 1 FROM %s%s x",
365 : pk_only, pkrelname);
366 1622 : querysep = "WHERE";
367 3388 : for (int i = 0; i < riinfo->nkeys; i++)
368 : {
369 1766 : Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
370 1766 : Oid fk_type = RIAttType(fk_rel, riinfo->fk_attnums[i]);
371 :
372 1766 : quoteOneName(attname,
373 1766 : RIAttName(pk_rel, riinfo->pk_attnums[i]));
374 1766 : sprintf(paramname, "$%d", i + 1);
375 1766 : ri_GenerateQual(&querybuf, querysep,
376 : attname, pk_type,
377 : riinfo->pf_eq_oprs[i],
378 : paramname, fk_type);
379 1766 : querysep = "AND";
380 1766 : queryoids[i] = fk_type;
381 : }
382 1622 : appendStringInfoString(&querybuf, " FOR KEY SHARE OF x");
383 :
384 : /* Prepare and save the plan */
385 1622 : qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys, queryoids,
386 : &qkey, fk_rel, pk_rel);
387 : }
388 :
389 : /*
390 : * Now check that foreign key exists in PK table
391 : */
392 2566 : ri_PerformCheck(riinfo, &qkey, qplan,
393 : fk_rel, pk_rel,
394 : NULL, newslot,
395 : false,
396 : SPI_OK_SELECT);
397 :
398 2286 : if (SPI_finish() != SPI_OK_FINISH)
399 0 : elog(ERROR, "SPI_finish failed");
400 :
401 2286 : table_close(pk_rel, RowShareLock);
402 :
403 2286 : return PointerGetDatum(NULL);
404 : }
405 :
406 :
407 : /*
408 : * RI_FKey_check_ins -
409 : *
410 : * Check foreign key existence at insert event on FK table.
411 : */
412 : Datum
413 2576 : RI_FKey_check_ins(PG_FUNCTION_ARGS)
414 : {
415 : /* Check that this is a valid trigger call on the right time and event. */
416 2576 : ri_CheckTrigger(fcinfo, "RI_FKey_check_ins", RI_TRIGTYPE_INSERT);
417 :
418 : /* Share code with UPDATE case. */
419 2576 : return RI_FKey_check((TriggerData *) fcinfo->context);
420 : }
421 :
422 :
423 : /*
424 : * RI_FKey_check_upd -
425 : *
426 : * Check foreign key existence at update event on FK table.
427 : */
428 : Datum
429 214 : RI_FKey_check_upd(PG_FUNCTION_ARGS)
430 : {
431 : /* Check that this is a valid trigger call on the right time and event. */
432 214 : ri_CheckTrigger(fcinfo, "RI_FKey_check_upd", RI_TRIGTYPE_UPDATE);
433 :
434 : /* Share code with INSERT case. */
435 214 : return RI_FKey_check((TriggerData *) fcinfo->context);
436 : }
437 :
438 :
439 : /*
440 : * ri_Check_Pk_Match
441 : *
442 : * Check to see if another PK row has been created that provides the same
443 : * key values as the "oldslot" that's been modified or deleted in our trigger
444 : * event. Returns true if a match is found in the PK table.
445 : *
446 : * We assume the caller checked that the oldslot contains no NULL key values,
447 : * since otherwise a match is impossible.
448 : */
449 : static bool
450 440 : ri_Check_Pk_Match(Relation pk_rel, Relation fk_rel,
451 : TupleTableSlot *oldslot,
452 : const RI_ConstraintInfo *riinfo)
453 : {
454 : SPIPlanPtr qplan;
455 : RI_QueryKey qkey;
456 : bool result;
457 :
458 : /* Only called for non-null rows */
459 : Assert(ri_NullCheck(RelationGetDescr(pk_rel), oldslot, riinfo, true) == RI_KEYS_NONE_NULL);
460 :
461 440 : if (SPI_connect() != SPI_OK_CONNECT)
462 0 : elog(ERROR, "SPI_connect failed");
463 :
464 : /*
465 : * Fetch or prepare a saved plan for checking PK table with values coming
466 : * from a PK row
467 : */
468 440 : ri_BuildQueryKey(&qkey, riinfo, RI_PLAN_CHECK_LOOKUPPK_FROM_PK);
469 :
470 440 : if ((qplan = ri_FetchPreparedPlan(&qkey)) == NULL)
471 : {
472 : StringInfoData querybuf;
473 : char pkrelname[MAX_QUOTED_REL_NAME_LEN];
474 : char attname[MAX_QUOTED_NAME_LEN];
475 : char paramname[16];
476 : const char *querysep;
477 : const char *pk_only;
478 : Oid queryoids[RI_MAX_NUMKEYS];
479 :
480 : /* ----------
481 : * The query string built is
482 : * SELECT 1 FROM [ONLY] <pktable> x WHERE pkatt1 = $1 [AND ...]
483 : * FOR KEY SHARE OF x
484 : * The type id's for the $ parameters are those of the
485 : * PK attributes themselves.
486 : * ----------
487 : */
488 196 : initStringInfo(&querybuf);
489 392 : pk_only = pk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
490 196 : "" : "ONLY ";
491 196 : quoteRelationName(pkrelname, pk_rel);
492 196 : appendStringInfo(&querybuf, "SELECT 1 FROM %s%s x",
493 : pk_only, pkrelname);
494 196 : querysep = "WHERE";
495 456 : for (int i = 0; i < riinfo->nkeys; i++)
496 : {
497 260 : Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
498 :
499 260 : quoteOneName(attname,
500 260 : RIAttName(pk_rel, riinfo->pk_attnums[i]));
501 260 : sprintf(paramname, "$%d", i + 1);
502 260 : ri_GenerateQual(&querybuf, querysep,
503 : attname, pk_type,
504 : riinfo->pp_eq_oprs[i],
505 : paramname, pk_type);
506 260 : querysep = "AND";
507 260 : queryoids[i] = pk_type;
508 : }
509 196 : appendStringInfoString(&querybuf, " FOR KEY SHARE OF x");
510 :
511 : /* Prepare and save the plan */
512 196 : qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys, queryoids,
513 : &qkey, fk_rel, pk_rel);
514 : }
515 :
516 : /*
517 : * We have a plan now. Run it.
518 : */
519 440 : result = ri_PerformCheck(riinfo, &qkey, qplan,
520 : fk_rel, pk_rel,
521 : oldslot, NULL,
522 : true, /* treat like update */
523 : SPI_OK_SELECT);
524 :
525 440 : if (SPI_finish() != SPI_OK_FINISH)
526 0 : elog(ERROR, "SPI_finish failed");
527 :
528 440 : return result;
529 : }
530 :
531 :
532 : /*
533 : * RI_FKey_noaction_del -
534 : *
535 : * Give an error and roll back the current transaction if the
536 : * delete has resulted in a violation of the given referential
537 : * integrity constraint.
538 : */
539 : Datum
540 220 : RI_FKey_noaction_del(PG_FUNCTION_ARGS)
541 : {
542 : /* Check that this is a valid trigger call on the right time and event. */
543 220 : ri_CheckTrigger(fcinfo, "RI_FKey_noaction_del", RI_TRIGTYPE_DELETE);
544 :
545 : /* Share code with RESTRICT/UPDATE cases. */
546 220 : return ri_restrict((TriggerData *) fcinfo->context, true);
547 : }
548 :
549 : /*
550 : * RI_FKey_restrict_del -
551 : *
552 : * Restrict delete from PK table to rows unreferenced by foreign key.
553 : *
554 : * The SQL standard intends that this referential action occur exactly when
555 : * the delete is performed, rather than after. This appears to be
556 : * the only difference between "NO ACTION" and "RESTRICT". In Postgres
557 : * we still implement this as an AFTER trigger, but it's non-deferrable.
558 : */
559 : Datum
560 12 : RI_FKey_restrict_del(PG_FUNCTION_ARGS)
561 : {
562 : /* Check that this is a valid trigger call on the right time and event. */
563 12 : ri_CheckTrigger(fcinfo, "RI_FKey_restrict_del", RI_TRIGTYPE_DELETE);
564 :
565 : /* Share code with NO ACTION/UPDATE cases. */
566 12 : return ri_restrict((TriggerData *) fcinfo->context, false);
567 : }
568 :
569 : /*
570 : * RI_FKey_noaction_upd -
571 : *
572 : * Give an error and roll back the current transaction if the
573 : * update has resulted in a violation of the given referential
574 : * integrity constraint.
575 : */
576 : Datum
577 152 : RI_FKey_noaction_upd(PG_FUNCTION_ARGS)
578 : {
579 : /* Check that this is a valid trigger call on the right time and event. */
580 152 : ri_CheckTrigger(fcinfo, "RI_FKey_noaction_upd", RI_TRIGTYPE_UPDATE);
581 :
582 : /* Share code with RESTRICT/DELETE cases. */
583 152 : return ri_restrict((TriggerData *) fcinfo->context, true);
584 : }
585 :
586 : /*
587 : * RI_FKey_restrict_upd -
588 : *
589 : * Restrict update of PK to rows unreferenced by foreign key.
590 : *
591 : * The SQL standard intends that this referential action occur exactly when
592 : * the update is performed, rather than after. This appears to be
593 : * the only difference between "NO ACTION" and "RESTRICT". In Postgres
594 : * we still implement this as an AFTER trigger, but it's non-deferrable.
595 : */
596 : Datum
597 12 : RI_FKey_restrict_upd(PG_FUNCTION_ARGS)
598 : {
599 : /* Check that this is a valid trigger call on the right time and event. */
600 12 : ri_CheckTrigger(fcinfo, "RI_FKey_restrict_upd", RI_TRIGTYPE_UPDATE);
601 :
602 : /* Share code with NO ACTION/DELETE cases. */
603 12 : return ri_restrict((TriggerData *) fcinfo->context, false);
604 : }
605 :
606 : /*
607 : * ri_restrict -
608 : *
609 : * Common code for ON DELETE RESTRICT, ON DELETE NO ACTION,
610 : * ON UPDATE RESTRICT, and ON UPDATE NO ACTION.
611 : */
612 : static Datum
613 464 : ri_restrict(TriggerData *trigdata, bool is_no_action)
614 : {
615 : const RI_ConstraintInfo *riinfo;
616 : Relation fk_rel;
617 : Relation pk_rel;
618 : TupleTableSlot *oldslot;
619 : RI_QueryKey qkey;
620 : SPIPlanPtr qplan;
621 :
622 464 : riinfo = ri_FetchConstraintInfo(trigdata->tg_trigger,
623 : trigdata->tg_relation, true);
624 :
625 : /*
626 : * Get the relation descriptors of the FK and PK tables and the old tuple.
627 : *
628 : * fk_rel is opened in RowShareLock mode since that's what our eventual
629 : * SELECT FOR KEY SHARE will get on it.
630 : */
631 464 : fk_rel = table_open(riinfo->fk_relid, RowShareLock);
632 464 : pk_rel = trigdata->tg_relation;
633 464 : oldslot = trigdata->tg_trigslot;
634 :
635 : /*
636 : * If another PK row now exists providing the old key values, we should
637 : * not do anything. However, this check should only be made in the NO
638 : * ACTION case; in RESTRICT cases we don't wish to allow another row to be
639 : * substituted.
640 : */
641 904 : if (is_no_action &&
642 440 : ri_Check_Pk_Match(pk_rel, fk_rel, oldslot, riinfo))
643 : {
644 12 : table_close(fk_rel, RowShareLock);
645 12 : return PointerGetDatum(NULL);
646 : }
647 :
648 452 : if (SPI_connect() != SPI_OK_CONNECT)
649 0 : elog(ERROR, "SPI_connect failed");
650 :
651 : /*
652 : * Fetch or prepare a saved plan for the restrict lookup (it's the same
653 : * query for delete and update cases)
654 : */
655 452 : ri_BuildQueryKey(&qkey, riinfo, RI_PLAN_RESTRICT_CHECKREF);
656 :
657 452 : if ((qplan = ri_FetchPreparedPlan(&qkey)) == NULL)
658 : {
659 : StringInfoData querybuf;
660 : char fkrelname[MAX_QUOTED_REL_NAME_LEN];
661 : char attname[MAX_QUOTED_NAME_LEN];
662 : char paramname[16];
663 : const char *querysep;
664 : Oid queryoids[RI_MAX_NUMKEYS];
665 : const char *fk_only;
666 :
667 : /* ----------
668 : * The query string built is
669 : * SELECT 1 FROM [ONLY] <fktable> x WHERE $1 = fkatt1 [AND ...]
670 : * FOR KEY SHARE OF x
671 : * The type id's for the $ parameters are those of the
672 : * corresponding PK attributes.
673 : * ----------
674 : */
675 208 : initStringInfo(&querybuf);
676 416 : fk_only = fk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
677 208 : "" : "ONLY ";
678 208 : quoteRelationName(fkrelname, fk_rel);
679 208 : appendStringInfo(&querybuf, "SELECT 1 FROM %s%s x",
680 : fk_only, fkrelname);
681 208 : querysep = "WHERE";
682 480 : for (int i = 0; i < riinfo->nkeys; i++)
683 : {
684 272 : Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
685 272 : Oid fk_type = RIAttType(fk_rel, riinfo->fk_attnums[i]);
686 272 : Oid pk_coll = RIAttCollation(pk_rel, riinfo->pk_attnums[i]);
687 272 : Oid fk_coll = RIAttCollation(fk_rel, riinfo->fk_attnums[i]);
688 :
689 272 : quoteOneName(attname,
690 272 : RIAttName(fk_rel, riinfo->fk_attnums[i]));
691 272 : sprintf(paramname, "$%d", i + 1);
692 272 : ri_GenerateQual(&querybuf, querysep,
693 : paramname, pk_type,
694 : riinfo->pf_eq_oprs[i],
695 : attname, fk_type);
696 272 : if (pk_coll != fk_coll && !get_collation_isdeterministic(pk_coll))
697 0 : ri_GenerateQualCollation(&querybuf, pk_coll);
698 272 : querysep = "AND";
699 272 : queryoids[i] = pk_type;
700 : }
701 208 : appendStringInfoString(&querybuf, " FOR KEY SHARE OF x");
702 :
703 : /* Prepare and save the plan */
704 208 : qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys, queryoids,
705 : &qkey, fk_rel, pk_rel);
706 : }
707 :
708 : /*
709 : * We have a plan now. Run it to check for existing references.
710 : */
711 452 : ri_PerformCheck(riinfo, &qkey, qplan,
712 : fk_rel, pk_rel,
713 : oldslot, NULL,
714 : true, /* must detect new rows */
715 : SPI_OK_SELECT);
716 :
717 250 : if (SPI_finish() != SPI_OK_FINISH)
718 0 : elog(ERROR, "SPI_finish failed");
719 :
720 250 : table_close(fk_rel, RowShareLock);
721 :
722 250 : return PointerGetDatum(NULL);
723 : }
724 :
725 :
726 : /*
727 : * RI_FKey_cascade_del -
728 : *
729 : * Cascaded delete foreign key references at delete event on PK table.
730 : */
731 : Datum
732 84 : RI_FKey_cascade_del(PG_FUNCTION_ARGS)
733 : {
734 84 : TriggerData *trigdata = (TriggerData *) fcinfo->context;
735 : const RI_ConstraintInfo *riinfo;
736 : Relation fk_rel;
737 : Relation pk_rel;
738 : TupleTableSlot *oldslot;
739 : RI_QueryKey qkey;
740 : SPIPlanPtr qplan;
741 :
742 : /* Check that this is a valid trigger call on the right time and event. */
743 84 : ri_CheckTrigger(fcinfo, "RI_FKey_cascade_del", RI_TRIGTYPE_DELETE);
744 :
745 84 : riinfo = ri_FetchConstraintInfo(trigdata->tg_trigger,
746 : trigdata->tg_relation, true);
747 :
748 : /*
749 : * Get the relation descriptors of the FK and PK tables and the old tuple.
750 : *
751 : * fk_rel is opened in RowExclusiveLock mode since that's what our
752 : * eventual DELETE will get on it.
753 : */
754 84 : fk_rel = table_open(riinfo->fk_relid, RowExclusiveLock);
755 84 : pk_rel = trigdata->tg_relation;
756 84 : oldslot = trigdata->tg_trigslot;
757 :
758 84 : if (SPI_connect() != SPI_OK_CONNECT)
759 0 : elog(ERROR, "SPI_connect failed");
760 :
761 : /* Fetch or prepare a saved plan for the cascaded delete */
762 84 : ri_BuildQueryKey(&qkey, riinfo, RI_PLAN_CASCADE_DEL_DODELETE);
763 :
764 84 : if ((qplan = ri_FetchPreparedPlan(&qkey)) == NULL)
765 : {
766 : StringInfoData querybuf;
767 : char fkrelname[MAX_QUOTED_REL_NAME_LEN];
768 : char attname[MAX_QUOTED_NAME_LEN];
769 : char paramname[16];
770 : const char *querysep;
771 : Oid queryoids[RI_MAX_NUMKEYS];
772 : const char *fk_only;
773 :
774 : /* ----------
775 : * The query string built is
776 : * DELETE FROM [ONLY] <fktable> WHERE $1 = fkatt1 [AND ...]
777 : * The type id's for the $ parameters are those of the
778 : * corresponding PK attributes.
779 : * ----------
780 : */
781 50 : initStringInfo(&querybuf);
782 100 : fk_only = fk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
783 50 : "" : "ONLY ";
784 50 : quoteRelationName(fkrelname, fk_rel);
785 50 : appendStringInfo(&querybuf, "DELETE FROM %s%s",
786 : fk_only, fkrelname);
787 50 : querysep = "WHERE";
788 116 : for (int i = 0; i < riinfo->nkeys; i++)
789 : {
790 66 : Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
791 66 : Oid fk_type = RIAttType(fk_rel, riinfo->fk_attnums[i]);
792 66 : Oid pk_coll = RIAttCollation(pk_rel, riinfo->pk_attnums[i]);
793 66 : Oid fk_coll = RIAttCollation(fk_rel, riinfo->fk_attnums[i]);
794 :
795 66 : quoteOneName(attname,
796 66 : RIAttName(fk_rel, riinfo->fk_attnums[i]));
797 66 : sprintf(paramname, "$%d", i + 1);
798 66 : ri_GenerateQual(&querybuf, querysep,
799 : paramname, pk_type,
800 : riinfo->pf_eq_oprs[i],
801 : attname, fk_type);
802 66 : if (pk_coll != fk_coll && !get_collation_isdeterministic(pk_coll))
803 0 : ri_GenerateQualCollation(&querybuf, pk_coll);
804 66 : querysep = "AND";
805 66 : queryoids[i] = pk_type;
806 : }
807 :
808 : /* Prepare and save the plan */
809 50 : qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys, queryoids,
810 : &qkey, fk_rel, pk_rel);
811 : }
812 :
813 : /*
814 : * We have a plan now. Build up the arguments from the key values in the
815 : * deleted PK tuple and delete the referencing rows
816 : */
817 84 : ri_PerformCheck(riinfo, &qkey, qplan,
818 : fk_rel, pk_rel,
819 : oldslot, NULL,
820 : true, /* must detect new rows */
821 : SPI_OK_DELETE);
822 :
823 84 : if (SPI_finish() != SPI_OK_FINISH)
824 0 : elog(ERROR, "SPI_finish failed");
825 :
826 84 : table_close(fk_rel, RowExclusiveLock);
827 :
828 84 : return PointerGetDatum(NULL);
829 : }
830 :
831 :
832 : /*
833 : * RI_FKey_cascade_upd -
834 : *
835 : * Cascaded update foreign key references at update event on PK table.
836 : */
837 : Datum
838 56 : RI_FKey_cascade_upd(PG_FUNCTION_ARGS)
839 : {
840 56 : TriggerData *trigdata = (TriggerData *) fcinfo->context;
841 : const RI_ConstraintInfo *riinfo;
842 : Relation fk_rel;
843 : Relation pk_rel;
844 : TupleTableSlot *newslot;
845 : TupleTableSlot *oldslot;
846 : RI_QueryKey qkey;
847 : SPIPlanPtr qplan;
848 :
849 : /* Check that this is a valid trigger call on the right time and event. */
850 56 : ri_CheckTrigger(fcinfo, "RI_FKey_cascade_upd", RI_TRIGTYPE_UPDATE);
851 :
852 56 : riinfo = ri_FetchConstraintInfo(trigdata->tg_trigger,
853 : trigdata->tg_relation, true);
854 :
855 : /*
856 : * Get the relation descriptors of the FK and PK tables and the new and
857 : * old tuple.
858 : *
859 : * fk_rel is opened in RowExclusiveLock mode since that's what our
860 : * eventual UPDATE will get on it.
861 : */
862 56 : fk_rel = table_open(riinfo->fk_relid, RowExclusiveLock);
863 56 : pk_rel = trigdata->tg_relation;
864 56 : newslot = trigdata->tg_newslot;
865 56 : oldslot = trigdata->tg_trigslot;
866 :
867 56 : if (SPI_connect() != SPI_OK_CONNECT)
868 0 : elog(ERROR, "SPI_connect failed");
869 :
870 : /* Fetch or prepare a saved plan for the cascaded update */
871 56 : ri_BuildQueryKey(&qkey, riinfo, RI_PLAN_CASCADE_UPD_DOUPDATE);
872 :
873 56 : if ((qplan = ri_FetchPreparedPlan(&qkey)) == NULL)
874 : {
875 : StringInfoData querybuf;
876 : StringInfoData qualbuf;
877 : char fkrelname[MAX_QUOTED_REL_NAME_LEN];
878 : char attname[MAX_QUOTED_NAME_LEN];
879 : char paramname[16];
880 : const char *querysep;
881 : const char *qualsep;
882 : Oid queryoids[RI_MAX_NUMKEYS * 2];
883 : const char *fk_only;
884 :
885 : /* ----------
886 : * The query string built is
887 : * UPDATE [ONLY] <fktable> SET fkatt1 = $1 [, ...]
888 : * WHERE $n = fkatt1 [AND ...]
889 : * The type id's for the $ parameters are those of the
890 : * corresponding PK attributes. Note that we are assuming
891 : * there is an assignment cast from the PK to the FK type;
892 : * else the parser will fail.
893 : * ----------
894 : */
895 46 : initStringInfo(&querybuf);
896 46 : initStringInfo(&qualbuf);
897 92 : fk_only = fk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
898 46 : "" : "ONLY ";
899 46 : quoteRelationName(fkrelname, fk_rel);
900 46 : appendStringInfo(&querybuf, "UPDATE %s%s SET",
901 : fk_only, fkrelname);
902 46 : querysep = "";
903 46 : qualsep = "WHERE";
904 112 : for (int i = 0, j = riinfo->nkeys; i < riinfo->nkeys; i++, j++)
905 : {
906 66 : Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
907 66 : Oid fk_type = RIAttType(fk_rel, riinfo->fk_attnums[i]);
908 66 : Oid pk_coll = RIAttCollation(pk_rel, riinfo->pk_attnums[i]);
909 66 : Oid fk_coll = RIAttCollation(fk_rel, riinfo->fk_attnums[i]);
910 :
911 66 : quoteOneName(attname,
912 66 : RIAttName(fk_rel, riinfo->fk_attnums[i]));
913 66 : appendStringInfo(&querybuf,
914 : "%s %s = $%d",
915 : querysep, attname, i + 1);
916 66 : sprintf(paramname, "$%d", j + 1);
917 66 : ri_GenerateQual(&qualbuf, qualsep,
918 : paramname, pk_type,
919 : riinfo->pf_eq_oprs[i],
920 : attname, fk_type);
921 66 : if (pk_coll != fk_coll && !get_collation_isdeterministic(pk_coll))
922 0 : ri_GenerateQualCollation(&querybuf, pk_coll);
923 66 : querysep = ",";
924 66 : qualsep = "AND";
925 66 : queryoids[i] = pk_type;
926 66 : queryoids[j] = pk_type;
927 : }
928 46 : appendBinaryStringInfo(&querybuf, qualbuf.data, qualbuf.len);
929 :
930 : /* Prepare and save the plan */
931 46 : qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys * 2, queryoids,
932 : &qkey, fk_rel, pk_rel);
933 : }
934 :
935 : /*
936 : * We have a plan now. Run it to update the existing references.
937 : */
938 56 : ri_PerformCheck(riinfo, &qkey, qplan,
939 : fk_rel, pk_rel,
940 : oldslot, newslot,
941 : true, /* must detect new rows */
942 : SPI_OK_UPDATE);
943 :
944 56 : if (SPI_finish() != SPI_OK_FINISH)
945 0 : elog(ERROR, "SPI_finish failed");
946 :
947 56 : table_close(fk_rel, RowExclusiveLock);
948 :
949 56 : return PointerGetDatum(NULL);
950 : }
951 :
952 :
953 : /*
954 : * RI_FKey_setnull_del -
955 : *
956 : * Set foreign key references to NULL values at delete event on PK table.
957 : */
958 : Datum
959 52 : RI_FKey_setnull_del(PG_FUNCTION_ARGS)
960 : {
961 : /* Check that this is a valid trigger call on the right time and event. */
962 52 : ri_CheckTrigger(fcinfo, "RI_FKey_setnull_del", RI_TRIGTYPE_DELETE);
963 :
964 : /* Share code with UPDATE case */
965 52 : return ri_set((TriggerData *) fcinfo->context, true);
966 : }
967 :
968 : /*
969 : * RI_FKey_setnull_upd -
970 : *
971 : * Set foreign key references to NULL at update event on PK table.
972 : */
973 : Datum
974 20 : RI_FKey_setnull_upd(PG_FUNCTION_ARGS)
975 : {
976 : /* Check that this is a valid trigger call on the right time and event. */
977 20 : ri_CheckTrigger(fcinfo, "RI_FKey_setnull_upd", RI_TRIGTYPE_UPDATE);
978 :
979 : /* Share code with DELETE case */
980 20 : return ri_set((TriggerData *) fcinfo->context, true);
981 : }
982 :
983 : /*
984 : * RI_FKey_setdefault_del -
985 : *
986 : * Set foreign key references to defaults at delete event on PK table.
987 : */
988 : Datum
989 40 : RI_FKey_setdefault_del(PG_FUNCTION_ARGS)
990 : {
991 : /* Check that this is a valid trigger call on the right time and event. */
992 40 : ri_CheckTrigger(fcinfo, "RI_FKey_setdefault_del", RI_TRIGTYPE_DELETE);
993 :
994 : /* Share code with UPDATE case */
995 40 : return ri_set((TriggerData *) fcinfo->context, false);
996 : }
997 :
998 : /*
999 : * RI_FKey_setdefault_upd -
1000 : *
1001 : * Set foreign key references to defaults at update event on PK table.
1002 : */
1003 : Datum
1004 28 : RI_FKey_setdefault_upd(PG_FUNCTION_ARGS)
1005 : {
1006 : /* Check that this is a valid trigger call on the right time and event. */
1007 28 : ri_CheckTrigger(fcinfo, "RI_FKey_setdefault_upd", RI_TRIGTYPE_UPDATE);
1008 :
1009 : /* Share code with DELETE case */
1010 28 : return ri_set((TriggerData *) fcinfo->context, false);
1011 : }
1012 :
1013 : /*
1014 : * ri_set -
1015 : *
1016 : * Common code for ON DELETE SET NULL, ON DELETE SET DEFAULT, ON UPDATE SET
1017 : * NULL, and ON UPDATE SET DEFAULT.
1018 : */
1019 : static Datum
1020 140 : ri_set(TriggerData *trigdata, bool is_set_null)
1021 : {
1022 : const RI_ConstraintInfo *riinfo;
1023 : Relation fk_rel;
1024 : Relation pk_rel;
1025 : TupleTableSlot *oldslot;
1026 : RI_QueryKey qkey;
1027 : SPIPlanPtr qplan;
1028 :
1029 140 : riinfo = ri_FetchConstraintInfo(trigdata->tg_trigger,
1030 : trigdata->tg_relation, true);
1031 :
1032 : /*
1033 : * Get the relation descriptors of the FK and PK tables and the old tuple.
1034 : *
1035 : * fk_rel is opened in RowExclusiveLock mode since that's what our
1036 : * eventual UPDATE will get on it.
1037 : */
1038 140 : fk_rel = table_open(riinfo->fk_relid, RowExclusiveLock);
1039 140 : pk_rel = trigdata->tg_relation;
1040 140 : oldslot = trigdata->tg_trigslot;
1041 :
1042 140 : if (SPI_connect() != SPI_OK_CONNECT)
1043 0 : elog(ERROR, "SPI_connect failed");
1044 :
1045 : /*
1046 : * Fetch or prepare a saved plan for the set null/default operation (it's
1047 : * the same query for delete and update cases)
1048 : */
1049 140 : ri_BuildQueryKey(&qkey, riinfo,
1050 : (is_set_null
1051 : ? RI_PLAN_SETNULL_DOUPDATE
1052 : : RI_PLAN_SETDEFAULT_DOUPDATE));
1053 :
1054 140 : if ((qplan = ri_FetchPreparedPlan(&qkey)) == NULL)
1055 : {
1056 : StringInfoData querybuf;
1057 : StringInfoData qualbuf;
1058 : char fkrelname[MAX_QUOTED_REL_NAME_LEN];
1059 : char attname[MAX_QUOTED_NAME_LEN];
1060 : char paramname[16];
1061 : const char *querysep;
1062 : const char *qualsep;
1063 : Oid queryoids[RI_MAX_NUMKEYS];
1064 : const char *fk_only;
1065 :
1066 : /* ----------
1067 : * The query string built is
1068 : * UPDATE [ONLY] <fktable> SET fkatt1 = {NULL|DEFAULT} [, ...]
1069 : * WHERE $1 = fkatt1 [AND ...]
1070 : * The type id's for the $ parameters are those of the
1071 : * corresponding PK attributes.
1072 : * ----------
1073 : */
1074 70 : initStringInfo(&querybuf);
1075 70 : initStringInfo(&qualbuf);
1076 140 : fk_only = fk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
1077 70 : "" : "ONLY ";
1078 70 : quoteRelationName(fkrelname, fk_rel);
1079 70 : appendStringInfo(&querybuf, "UPDATE %s%s SET",
1080 : fk_only, fkrelname);
1081 70 : querysep = "";
1082 70 : qualsep = "WHERE";
1083 200 : for (int i = 0; i < riinfo->nkeys; i++)
1084 : {
1085 130 : Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
1086 130 : Oid fk_type = RIAttType(fk_rel, riinfo->fk_attnums[i]);
1087 130 : Oid pk_coll = RIAttCollation(pk_rel, riinfo->pk_attnums[i]);
1088 130 : Oid fk_coll = RIAttCollation(fk_rel, riinfo->fk_attnums[i]);
1089 :
1090 130 : quoteOneName(attname,
1091 130 : RIAttName(fk_rel, riinfo->fk_attnums[i]));
1092 130 : appendStringInfo(&querybuf,
1093 : "%s %s = %s",
1094 : querysep, attname,
1095 : is_set_null ? "NULL" : "DEFAULT");
1096 130 : sprintf(paramname, "$%d", i + 1);
1097 130 : ri_GenerateQual(&qualbuf, qualsep,
1098 : paramname, pk_type,
1099 : riinfo->pf_eq_oprs[i],
1100 : attname, fk_type);
1101 130 : if (pk_coll != fk_coll && !get_collation_isdeterministic(pk_coll))
1102 0 : ri_GenerateQualCollation(&querybuf, pk_coll);
1103 130 : querysep = ",";
1104 130 : qualsep = "AND";
1105 130 : queryoids[i] = pk_type;
1106 : }
1107 70 : appendBinaryStringInfo(&querybuf, qualbuf.data, qualbuf.len);
1108 :
1109 : /* Prepare and save the plan */
1110 70 : qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys, queryoids,
1111 : &qkey, fk_rel, pk_rel);
1112 : }
1113 :
1114 : /*
1115 : * We have a plan now. Run it to update the existing references.
1116 : */
1117 140 : ri_PerformCheck(riinfo, &qkey, qplan,
1118 : fk_rel, pk_rel,
1119 : oldslot, NULL,
1120 : true, /* must detect new rows */
1121 : SPI_OK_UPDATE);
1122 :
1123 140 : if (SPI_finish() != SPI_OK_FINISH)
1124 0 : elog(ERROR, "SPI_finish failed");
1125 :
1126 140 : table_close(fk_rel, RowExclusiveLock);
1127 :
1128 140 : if (is_set_null)
1129 72 : return PointerGetDatum(NULL);
1130 : else
1131 : {
1132 : /*
1133 : * If we just deleted or updated the PK row whose key was equal to the
1134 : * FK columns' default values, and a referencing row exists in the FK
1135 : * table, we would have updated that row to the same values it already
1136 : * had --- and RI_FKey_fk_upd_check_required would hence believe no
1137 : * check is necessary. So we need to do another lookup now and in
1138 : * case a reference still exists, abort the operation. That is
1139 : * already implemented in the NO ACTION trigger, so just run it. (This
1140 : * recheck is only needed in the SET DEFAULT case, since CASCADE would
1141 : * remove such rows in case of a DELETE operation or would change the
1142 : * FK key values in case of an UPDATE, while SET NULL is certain to
1143 : * result in rows that satisfy the FK constraint.)
1144 : */
1145 68 : return ri_restrict(trigdata, true);
1146 : }
1147 : }
1148 :
1149 :
1150 : /*
1151 : * RI_FKey_pk_upd_check_required -
1152 : *
1153 : * Check if we really need to fire the RI trigger for an update or delete to a PK
1154 : * relation. This is called by the AFTER trigger queue manager to see if
1155 : * it can skip queuing an instance of an RI trigger. Returns true if the
1156 : * trigger must be fired, false if we can prove the constraint will still
1157 : * be satisfied.
1158 : *
1159 : * newslot will be NULL if this is called for a delete.
1160 : */
1161 : bool
1162 1184 : RI_FKey_pk_upd_check_required(Trigger *trigger, Relation pk_rel,
1163 : TupleTableSlot *oldslot, TupleTableSlot *newslot)
1164 : {
1165 : const RI_ConstraintInfo *riinfo;
1166 :
1167 1184 : riinfo = ri_FetchConstraintInfo(trigger, pk_rel, true);
1168 :
1169 : /*
1170 : * If any old key value is NULL, the row could not have been referenced by
1171 : * an FK row, so no check is needed.
1172 : */
1173 1184 : if (ri_NullCheck(RelationGetDescr(pk_rel), oldslot, riinfo, true) != RI_KEYS_NONE_NULL)
1174 4 : return false;
1175 :
1176 : /* If all old and new key values are equal, no check is needed */
1177 1180 : if (newslot && ri_KeysEqual(pk_rel, oldslot, newslot, riinfo, true))
1178 472 : return false;
1179 :
1180 : /* Else we need to fire the trigger. */
1181 708 : return true;
1182 : }
1183 :
1184 : /*
1185 : * RI_FKey_fk_upd_check_required -
1186 : *
1187 : * Check if we really need to fire the RI trigger for an update to an FK
1188 : * relation. This is called by the AFTER trigger queue manager to see if
1189 : * it can skip queuing an instance of an RI trigger. Returns true if the
1190 : * trigger must be fired, false if we can prove the constraint will still
1191 : * be satisfied.
1192 : */
1193 : bool
1194 678 : RI_FKey_fk_upd_check_required(Trigger *trigger, Relation fk_rel,
1195 : TupleTableSlot *oldslot, TupleTableSlot *newslot)
1196 : {
1197 : const RI_ConstraintInfo *riinfo;
1198 : int ri_nullcheck;
1199 : Datum xminDatum;
1200 : TransactionId xmin;
1201 : bool isnull;
1202 :
1203 678 : riinfo = ri_FetchConstraintInfo(trigger, fk_rel, false);
1204 :
1205 678 : ri_nullcheck = ri_NullCheck(RelationGetDescr(fk_rel), newslot, riinfo, false);
1206 :
1207 : /*
1208 : * If all new key values are NULL, the row satisfies the constraint, so no
1209 : * check is needed.
1210 : */
1211 678 : if (ri_nullcheck == RI_KEYS_ALL_NULL)
1212 84 : return false;
1213 :
1214 : /*
1215 : * If some new key values are NULL, the behavior depends on the match
1216 : * type.
1217 : */
1218 594 : else if (ri_nullcheck == RI_KEYS_SOME_NULL)
1219 : {
1220 8 : switch (riinfo->confmatchtype)
1221 : {
1222 4 : case FKCONSTR_MATCH_SIMPLE:
1223 :
1224 : /*
1225 : * If any new key value is NULL, the row must satisfy the
1226 : * constraint, so no check is needed.
1227 : */
1228 4 : return false;
1229 :
1230 0 : case FKCONSTR_MATCH_PARTIAL:
1231 :
1232 : /*
1233 : * Don't know, must run full check.
1234 : */
1235 0 : break;
1236 :
1237 4 : case FKCONSTR_MATCH_FULL:
1238 :
1239 : /*
1240 : * If some new key values are NULL, the row fails the
1241 : * constraint. We must not throw error here, because the row
1242 : * might get invalidated before the constraint is to be
1243 : * checked, but we should queue the event to apply the check
1244 : * later.
1245 : */
1246 4 : return true;
1247 : }
1248 586 : }
1249 :
1250 : /*
1251 : * Continues here for no new key values are NULL, or we couldn't decide
1252 : * yet.
1253 : */
1254 :
1255 : /*
1256 : * If the original row was inserted by our own transaction, we must fire
1257 : * the trigger whether or not the keys are equal. This is because our
1258 : * UPDATE will invalidate the INSERT so that the INSERT RI trigger will
1259 : * not do anything; so we had better do the UPDATE check. (We could skip
1260 : * this if we knew the INSERT trigger already fired, but there is no easy
1261 : * way to know that.)
1262 : */
1263 586 : xminDatum = slot_getsysattr(oldslot, MinTransactionIdAttributeNumber, &isnull);
1264 : Assert(!isnull);
1265 586 : xmin = DatumGetTransactionId(xminDatum);
1266 586 : if (TransactionIdIsCurrentTransactionId(xmin))
1267 94 : return true;
1268 :
1269 : /* If all old and new key values are equal, no check is needed */
1270 492 : if (ri_KeysEqual(fk_rel, oldslot, newslot, riinfo, false))
1271 372 : return false;
1272 :
1273 : /* Else we need to fire the trigger. */
1274 120 : return true;
1275 : }
1276 :
1277 : /*
1278 : * RI_Initial_Check -
1279 : *
1280 : * Check an entire table for non-matching values using a single query.
1281 : * This is not a trigger procedure, but is called during ALTER TABLE
1282 : * ADD FOREIGN KEY to validate the initial table contents.
1283 : *
1284 : * We expect that the caller has made provision to prevent any problems
1285 : * caused by concurrent actions. This could be either by locking rel and
1286 : * pkrel at ShareRowExclusiveLock or higher, or by otherwise ensuring
1287 : * that triggers implementing the checks are already active.
1288 : * Hence, we do not need to lock individual rows for the check.
1289 : *
1290 : * If the check fails because the current user doesn't have permissions
1291 : * to read both tables, return false to let our caller know that they will
1292 : * need to do something else to check the constraint.
1293 : */
1294 : bool
1295 638 : RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
1296 : {
1297 : const RI_ConstraintInfo *riinfo;
1298 : StringInfoData querybuf;
1299 : char pkrelname[MAX_QUOTED_REL_NAME_LEN];
1300 : char fkrelname[MAX_QUOTED_REL_NAME_LEN];
1301 : char pkattname[MAX_QUOTED_NAME_LEN + 3];
1302 : char fkattname[MAX_QUOTED_NAME_LEN + 3];
1303 : RangeTblEntry *pkrte;
1304 : RangeTblEntry *fkrte;
1305 : const char *sep;
1306 : const char *fk_only;
1307 : const char *pk_only;
1308 : int save_nestlevel;
1309 : char workmembuf[32];
1310 : int spi_result;
1311 : SPIPlanPtr qplan;
1312 :
1313 638 : riinfo = ri_FetchConstraintInfo(trigger, fk_rel, false);
1314 :
1315 : /*
1316 : * Check to make sure current user has enough permissions to do the test
1317 : * query. (If not, caller can fall back to the trigger method, which
1318 : * works because it changes user IDs on the fly.)
1319 : *
1320 : * XXX are there any other show-stopper conditions to check?
1321 : */
1322 638 : pkrte = makeNode(RangeTblEntry);
1323 638 : pkrte->rtekind = RTE_RELATION;
1324 638 : pkrte->relid = RelationGetRelid(pk_rel);
1325 638 : pkrte->relkind = pk_rel->rd_rel->relkind;
1326 638 : pkrte->rellockmode = AccessShareLock;
1327 638 : pkrte->requiredPerms = ACL_SELECT;
1328 :
1329 638 : fkrte = makeNode(RangeTblEntry);
1330 638 : fkrte->rtekind = RTE_RELATION;
1331 638 : fkrte->relid = RelationGetRelid(fk_rel);
1332 638 : fkrte->relkind = fk_rel->rd_rel->relkind;
1333 638 : fkrte->rellockmode = AccessShareLock;
1334 638 : fkrte->requiredPerms = ACL_SELECT;
1335 :
1336 1434 : for (int i = 0; i < riinfo->nkeys; i++)
1337 : {
1338 : int attno;
1339 :
1340 796 : attno = riinfo->pk_attnums[i] - FirstLowInvalidHeapAttributeNumber;
1341 796 : pkrte->selectedCols = bms_add_member(pkrte->selectedCols, attno);
1342 :
1343 796 : attno = riinfo->fk_attnums[i] - FirstLowInvalidHeapAttributeNumber;
1344 796 : fkrte->selectedCols = bms_add_member(fkrte->selectedCols, attno);
1345 : }
1346 :
1347 638 : if (!ExecCheckRTPerms(list_make2(fkrte, pkrte), false))
1348 8 : return false;
1349 :
1350 : /*
1351 : * Also punt if RLS is enabled on either table unless this role has the
1352 : * bypassrls right or is the table owner of the table(s) involved which
1353 : * have RLS enabled.
1354 : */
1355 630 : if (!has_bypassrls_privilege(GetUserId()) &&
1356 0 : ((pk_rel->rd_rel->relrowsecurity &&
1357 0 : !pg_class_ownercheck(pkrte->relid, GetUserId())) ||
1358 0 : (fk_rel->rd_rel->relrowsecurity &&
1359 0 : !pg_class_ownercheck(fkrte->relid, GetUserId()))))
1360 0 : return false;
1361 :
1362 : /*----------
1363 : * The query string built is:
1364 : * SELECT fk.keycols FROM [ONLY] relname fk
1365 : * LEFT OUTER JOIN [ONLY] pkrelname pk
1366 : * ON (pk.pkkeycol1=fk.keycol1 [AND ...])
1367 : * WHERE pk.pkkeycol1 IS NULL AND
1368 : * For MATCH SIMPLE:
1369 : * (fk.keycol1 IS NOT NULL [AND ...])
1370 : * For MATCH FULL:
1371 : * (fk.keycol1 IS NOT NULL [OR ...])
1372 : *
1373 : * We attach COLLATE clauses to the operators when comparing columns
1374 : * that have different collations.
1375 : *----------
1376 : */
1377 630 : initStringInfo(&querybuf);
1378 630 : appendStringInfoString(&querybuf, "SELECT ");
1379 630 : sep = "";
1380 1410 : for (int i = 0; i < riinfo->nkeys; i++)
1381 : {
1382 780 : quoteOneName(fkattname,
1383 780 : RIAttName(fk_rel, riinfo->fk_attnums[i]));
1384 780 : appendStringInfo(&querybuf, "%sfk.%s", sep, fkattname);
1385 780 : sep = ", ";
1386 : }
1387 :
1388 630 : quoteRelationName(pkrelname, pk_rel);
1389 630 : quoteRelationName(fkrelname, fk_rel);
1390 1260 : fk_only = fk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
1391 630 : "" : "ONLY ";
1392 1260 : pk_only = pk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
1393 630 : "" : "ONLY ";
1394 630 : appendStringInfo(&querybuf,
1395 : " FROM %s%s fk LEFT OUTER JOIN %s%s pk ON",
1396 : fk_only, fkrelname, pk_only, pkrelname);
1397 :
1398 630 : strcpy(pkattname, "pk.");
1399 630 : strcpy(fkattname, "fk.");
1400 630 : sep = "(";
1401 1410 : for (int i = 0; i < riinfo->nkeys; i++)
1402 : {
1403 780 : Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
1404 780 : Oid fk_type = RIAttType(fk_rel, riinfo->fk_attnums[i]);
1405 780 : Oid pk_coll = RIAttCollation(pk_rel, riinfo->pk_attnums[i]);
1406 780 : Oid fk_coll = RIAttCollation(fk_rel, riinfo->fk_attnums[i]);
1407 :
1408 780 : quoteOneName(pkattname + 3,
1409 780 : RIAttName(pk_rel, riinfo->pk_attnums[i]));
1410 780 : quoteOneName(fkattname + 3,
1411 780 : RIAttName(fk_rel, riinfo->fk_attnums[i]));
1412 780 : ri_GenerateQual(&querybuf, sep,
1413 : pkattname, pk_type,
1414 : riinfo->pf_eq_oprs[i],
1415 : fkattname, fk_type);
1416 780 : if (pk_coll != fk_coll)
1417 8 : ri_GenerateQualCollation(&querybuf, pk_coll);
1418 780 : sep = "AND";
1419 : }
1420 :
1421 : /*
1422 : * It's sufficient to test any one pk attribute for null to detect a join
1423 : * failure.
1424 : */
1425 630 : quoteOneName(pkattname, RIAttName(pk_rel, riinfo->pk_attnums[0]));
1426 630 : appendStringInfo(&querybuf, ") WHERE pk.%s IS NULL AND (", pkattname);
1427 :
1428 630 : sep = "";
1429 1410 : for (int i = 0; i < riinfo->nkeys; i++)
1430 : {
1431 780 : quoteOneName(fkattname, RIAttName(fk_rel, riinfo->fk_attnums[i]));
1432 780 : appendStringInfo(&querybuf,
1433 : "%sfk.%s IS NOT NULL",
1434 : sep, fkattname);
1435 780 : switch (riinfo->confmatchtype)
1436 : {
1437 712 : case FKCONSTR_MATCH_SIMPLE:
1438 712 : sep = " AND ";
1439 712 : break;
1440 68 : case FKCONSTR_MATCH_FULL:
1441 68 : sep = " OR ";
1442 68 : break;
1443 : }
1444 780 : }
1445 630 : appendStringInfoChar(&querybuf, ')');
1446 :
1447 : /*
1448 : * Temporarily increase work_mem so that the check query can be executed
1449 : * more efficiently. It seems okay to do this because the query is simple
1450 : * enough to not use a multiple of work_mem, and one typically would not
1451 : * have many large foreign-key validations happening concurrently. So
1452 : * this seems to meet the criteria for being considered a "maintenance"
1453 : * operation, and accordingly we use maintenance_work_mem.
1454 : *
1455 : * We use the equivalent of a function SET option to allow the setting to
1456 : * persist for exactly the duration of the check query. guc.c also takes
1457 : * care of undoing the setting on error.
1458 : */
1459 630 : save_nestlevel = NewGUCNestLevel();
1460 :
1461 630 : snprintf(workmembuf, sizeof(workmembuf), "%d", maintenance_work_mem);
1462 630 : (void) set_config_option("work_mem", workmembuf,
1463 : PGC_USERSET, PGC_S_SESSION,
1464 : GUC_ACTION_SAVE, true, 0, false);
1465 :
1466 630 : if (SPI_connect() != SPI_OK_CONNECT)
1467 0 : elog(ERROR, "SPI_connect failed");
1468 :
1469 : /*
1470 : * Generate the plan. We don't need to cache it, and there are no
1471 : * arguments to the plan.
1472 : */
1473 630 : qplan = SPI_prepare(querybuf.data, 0, NULL);
1474 :
1475 630 : if (qplan == NULL)
1476 0 : elog(ERROR, "SPI_prepare returned %s for %s",
1477 : SPI_result_code_string(SPI_result), querybuf.data);
1478 :
1479 : /*
1480 : * Run the plan. For safety we force a current snapshot to be used. (In
1481 : * transaction-snapshot mode, this arguably violates transaction isolation
1482 : * rules, but we really haven't got much choice.) We don't need to
1483 : * register the snapshot, because SPI_execute_snapshot will see to it. We
1484 : * need at most one tuple returned, so pass limit = 1.
1485 : */
1486 630 : spi_result = SPI_execute_snapshot(qplan,
1487 : NULL, NULL,
1488 : GetLatestSnapshot(),
1489 : InvalidSnapshot,
1490 : true, false, 1);
1491 :
1492 : /* Check result */
1493 630 : if (spi_result != SPI_OK_SELECT)
1494 0 : elog(ERROR, "SPI_execute_snapshot returned %s", SPI_result_code_string(spi_result));
1495 :
1496 : /* Did we find a tuple violating the constraint? */
1497 630 : if (SPI_processed > 0)
1498 : {
1499 : TupleTableSlot *slot;
1500 42 : HeapTuple tuple = SPI_tuptable->vals[0];
1501 42 : TupleDesc tupdesc = SPI_tuptable->tupdesc;
1502 : RI_ConstraintInfo fake_riinfo;
1503 :
1504 42 : slot = MakeSingleTupleTableSlot(tupdesc, &TTSOpsVirtual);
1505 :
1506 42 : heap_deform_tuple(tuple, tupdesc,
1507 : slot->tts_values, slot->tts_isnull);
1508 42 : ExecStoreVirtualTuple(slot);
1509 :
1510 : /*
1511 : * The columns to look at in the result tuple are 1..N, not whatever
1512 : * they are in the fk_rel. Hack up riinfo so that the subroutines
1513 : * called here will behave properly.
1514 : *
1515 : * In addition to this, we have to pass the correct tupdesc to
1516 : * ri_ReportViolation, overriding its normal habit of using the pk_rel
1517 : * or fk_rel's tupdesc.
1518 : */
1519 42 : memcpy(&fake_riinfo, riinfo, sizeof(RI_ConstraintInfo));
1520 96 : for (int i = 0; i < fake_riinfo.nkeys; i++)
1521 54 : fake_riinfo.fk_attnums[i] = i + 1;
1522 :
1523 : /*
1524 : * If it's MATCH FULL, and there are any nulls in the FK keys,
1525 : * complain about that rather than the lack of a match. MATCH FULL
1526 : * disallows partially-null FK rows.
1527 : */
1528 58 : if (fake_riinfo.confmatchtype == FKCONSTR_MATCH_FULL &&
1529 16 : ri_NullCheck(tupdesc, slot, &fake_riinfo, false) != RI_KEYS_NONE_NULL)
1530 8 : ereport(ERROR,
1531 : (errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
1532 : errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
1533 : RelationGetRelationName(fk_rel),
1534 : NameStr(fake_riinfo.conname)),
1535 : errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
1536 : errtableconstraint(fk_rel,
1537 : NameStr(fake_riinfo.conname))));
1538 :
1539 : /*
1540 : * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
1541 : * query, which isn't true, but will cause it to use
1542 : * fake_riinfo.fk_attnums as we need.
1543 : */
1544 34 : ri_ReportViolation(&fake_riinfo,
1545 : pk_rel, fk_rel,
1546 : slot, tupdesc,
1547 : RI_PLAN_CHECK_LOOKUPPK, false);
1548 :
1549 : ExecDropSingleTupleTableSlot(slot);
1550 : }
1551 :
1552 588 : if (SPI_finish() != SPI_OK_FINISH)
1553 0 : elog(ERROR, "SPI_finish failed");
1554 :
1555 : /*
1556 : * Restore work_mem.
1557 : */
1558 588 : AtEOXact_GUC(true, save_nestlevel);
1559 :
1560 588 : return true;
1561 : }
1562 :
1563 : /*
1564 : * RI_PartitionRemove_Check -
1565 : *
1566 : * Verify no referencing values exist, when a partition is detached on
1567 : * the referenced side of a foreign key constraint.
1568 : */
1569 : void
1570 24 : RI_PartitionRemove_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
1571 : {
1572 : const RI_ConstraintInfo *riinfo;
1573 : StringInfoData querybuf;
1574 : char *constraintDef;
1575 : char pkrelname[MAX_QUOTED_REL_NAME_LEN];
1576 : char fkrelname[MAX_QUOTED_REL_NAME_LEN];
1577 : char pkattname[MAX_QUOTED_NAME_LEN + 3];
1578 : char fkattname[MAX_QUOTED_NAME_LEN + 3];
1579 : const char *sep;
1580 : const char *fk_only;
1581 : int save_nestlevel;
1582 : char workmembuf[32];
1583 : int spi_result;
1584 : SPIPlanPtr qplan;
1585 : int i;
1586 :
1587 24 : riinfo = ri_FetchConstraintInfo(trigger, fk_rel, false);
1588 :
1589 : /*
1590 : * We don't check permissions before displaying the error message, on the
1591 : * assumption that the user detaching the partition must have enough
1592 : * privileges to examine the table contents anyhow.
1593 : */
1594 :
1595 : /*----------
1596 : * The query string built is:
1597 : * SELECT fk.keycols FROM [ONLY] relname fk
1598 : * JOIN pkrelname pk
1599 : * ON (pk.pkkeycol1=fk.keycol1 [AND ...])
1600 : * WHERE (<partition constraint>) AND
1601 : * For MATCH SIMPLE:
1602 : * (fk.keycol1 IS NOT NULL [AND ...])
1603 : * For MATCH FULL:
1604 : * (fk.keycol1 IS NOT NULL [OR ...])
1605 : *
1606 : * We attach COLLATE clauses to the operators when comparing columns
1607 : * that have different collations.
1608 : *----------
1609 : */
1610 24 : initStringInfo(&querybuf);
1611 24 : appendStringInfoString(&querybuf, "SELECT ");
1612 24 : sep = "";
1613 48 : for (i = 0; i < riinfo->nkeys; i++)
1614 : {
1615 24 : quoteOneName(fkattname,
1616 24 : RIAttName(fk_rel, riinfo->fk_attnums[i]));
1617 24 : appendStringInfo(&querybuf, "%sfk.%s", sep, fkattname);
1618 24 : sep = ", ";
1619 : }
1620 :
1621 24 : quoteRelationName(pkrelname, pk_rel);
1622 24 : quoteRelationName(fkrelname, fk_rel);
1623 48 : fk_only = fk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
1624 24 : "" : "ONLY ";
1625 24 : appendStringInfo(&querybuf,
1626 : " FROM %s%s fk JOIN %s pk ON",
1627 : fk_only, fkrelname, pkrelname);
1628 24 : strcpy(pkattname, "pk.");
1629 24 : strcpy(fkattname, "fk.");
1630 24 : sep = "(";
1631 48 : for (i = 0; i < riinfo->nkeys; i++)
1632 : {
1633 24 : Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
1634 24 : Oid fk_type = RIAttType(fk_rel, riinfo->fk_attnums[i]);
1635 24 : Oid pk_coll = RIAttCollation(pk_rel, riinfo->pk_attnums[i]);
1636 24 : Oid fk_coll = RIAttCollation(fk_rel, riinfo->fk_attnums[i]);
1637 :
1638 24 : quoteOneName(pkattname + 3,
1639 24 : RIAttName(pk_rel, riinfo->pk_attnums[i]));
1640 24 : quoteOneName(fkattname + 3,
1641 24 : RIAttName(fk_rel, riinfo->fk_attnums[i]));
1642 24 : ri_GenerateQual(&querybuf, sep,
1643 : pkattname, pk_type,
1644 : riinfo->pf_eq_oprs[i],
1645 : fkattname, fk_type);
1646 24 : if (pk_coll != fk_coll)
1647 0 : ri_GenerateQualCollation(&querybuf, pk_coll);
1648 24 : sep = "AND";
1649 : }
1650 :
1651 : /*
1652 : * Start the WHERE clause with the partition constraint (except if this is
1653 : * the default partition and there's no other partition, because the
1654 : * partition constraint is the empty string in that case.)
1655 : */
1656 24 : constraintDef = pg_get_partconstrdef_string(RelationGetRelid(pk_rel), "pk");
1657 24 : if (constraintDef && constraintDef[0] != '\0')
1658 24 : appendStringInfo(&querybuf, ") WHERE %s AND (",
1659 : constraintDef);
1660 : else
1661 0 : appendStringInfo(&querybuf, ") WHERE (");
1662 :
1663 24 : sep = "";
1664 48 : for (i = 0; i < riinfo->nkeys; i++)
1665 : {
1666 24 : quoteOneName(fkattname, RIAttName(fk_rel, riinfo->fk_attnums[i]));
1667 24 : appendStringInfo(&querybuf,
1668 : "%sfk.%s IS NOT NULL",
1669 : sep, fkattname);
1670 24 : switch (riinfo->confmatchtype)
1671 : {
1672 24 : case FKCONSTR_MATCH_SIMPLE:
1673 24 : sep = " AND ";
1674 24 : break;
1675 0 : case FKCONSTR_MATCH_FULL:
1676 0 : sep = " OR ";
1677 0 : break;
1678 : }
1679 24 : }
1680 24 : appendStringInfoChar(&querybuf, ')');
1681 :
1682 : /*
1683 : * Temporarily increase work_mem so that the check query can be executed
1684 : * more efficiently. It seems okay to do this because the query is simple
1685 : * enough to not use a multiple of work_mem, and one typically would not
1686 : * have many large foreign-key validations happening concurrently. So
1687 : * this seems to meet the criteria for being considered a "maintenance"
1688 : * operation, and accordingly we use maintenance_work_mem.
1689 : *
1690 : * We use the equivalent of a function SET option to allow the setting to
1691 : * persist for exactly the duration of the check query. guc.c also takes
1692 : * care of undoing the setting on error.
1693 : */
1694 24 : save_nestlevel = NewGUCNestLevel();
1695 :
1696 24 : snprintf(workmembuf, sizeof(workmembuf), "%d", maintenance_work_mem);
1697 24 : (void) set_config_option("work_mem", workmembuf,
1698 : PGC_USERSET, PGC_S_SESSION,
1699 : GUC_ACTION_SAVE, true, 0, false);
1700 :
1701 24 : if (SPI_connect() != SPI_OK_CONNECT)
1702 0 : elog(ERROR, "SPI_connect failed");
1703 :
1704 : /*
1705 : * Generate the plan. We don't need to cache it, and there are no
1706 : * arguments to the plan.
1707 : */
1708 24 : qplan = SPI_prepare(querybuf.data, 0, NULL);
1709 :
1710 24 : if (qplan == NULL)
1711 0 : elog(ERROR, "SPI_prepare returned %s for %s",
1712 : SPI_result_code_string(SPI_result), querybuf.data);
1713 :
1714 : /*
1715 : * Run the plan. For safety we force a current snapshot to be used. (In
1716 : * transaction-snapshot mode, this arguably violates transaction isolation
1717 : * rules, but we really haven't got much choice.) We don't need to
1718 : * register the snapshot, because SPI_execute_snapshot will see to it. We
1719 : * need at most one tuple returned, so pass limit = 1.
1720 : */
1721 24 : spi_result = SPI_execute_snapshot(qplan,
1722 : NULL, NULL,
1723 : GetLatestSnapshot(),
1724 : InvalidSnapshot,
1725 : true, false, 1);
1726 :
1727 : /* Check result */
1728 24 : if (spi_result != SPI_OK_SELECT)
1729 0 : elog(ERROR, "SPI_execute_snapshot returned %s", SPI_result_code_string(spi_result));
1730 :
1731 : /* Did we find a tuple that would violate the constraint? */
1732 24 : if (SPI_processed > 0)
1733 : {
1734 : TupleTableSlot *slot;
1735 20 : HeapTuple tuple = SPI_tuptable->vals[0];
1736 20 : TupleDesc tupdesc = SPI_tuptable->tupdesc;
1737 : RI_ConstraintInfo fake_riinfo;
1738 :
1739 20 : slot = MakeSingleTupleTableSlot(tupdesc, &TTSOpsVirtual);
1740 :
1741 20 : heap_deform_tuple(tuple, tupdesc,
1742 : slot->tts_values, slot->tts_isnull);
1743 20 : ExecStoreVirtualTuple(slot);
1744 :
1745 : /*
1746 : * The columns to look at in the result tuple are 1..N, not whatever
1747 : * they are in the fk_rel. Hack up riinfo so that ri_ReportViolation
1748 : * will behave properly.
1749 : *
1750 : * In addition to this, we have to pass the correct tupdesc to
1751 : * ri_ReportViolation, overriding its normal habit of using the pk_rel
1752 : * or fk_rel's tupdesc.
1753 : */
1754 20 : memcpy(&fake_riinfo, riinfo, sizeof(RI_ConstraintInfo));
1755 40 : for (i = 0; i < fake_riinfo.nkeys; i++)
1756 20 : fake_riinfo.pk_attnums[i] = i + 1;
1757 :
1758 20 : ri_ReportViolation(&fake_riinfo, pk_rel, fk_rel,
1759 : slot, tupdesc, 0, true);
1760 : }
1761 :
1762 4 : if (SPI_finish() != SPI_OK_FINISH)
1763 0 : elog(ERROR, "SPI_finish failed");
1764 :
1765 : /*
1766 : * Restore work_mem.
1767 : */
1768 4 : AtEOXact_GUC(true, save_nestlevel);
1769 4 : }
1770 :
1771 :
1772 : /* ----------
1773 : * Local functions below
1774 : * ----------
1775 : */
1776 :
1777 :
1778 : /*
1779 : * quoteOneName --- safely quote a single SQL name
1780 : *
1781 : * buffer must be MAX_QUOTED_NAME_LEN long (includes room for \0)
1782 : */
1783 : static void
1784 13422 : quoteOneName(char *buffer, const char *name)
1785 : {
1786 : /* Rather than trying to be smart, just always quote it. */
1787 13422 : *buffer++ = '"';
1788 80380 : while (*name)
1789 : {
1790 66958 : if (*name == '"')
1791 0 : *buffer++ = '"';
1792 66958 : *buffer++ = *name++;
1793 : }
1794 13422 : *buffer++ = '"';
1795 13422 : *buffer = '\0';
1796 13422 : }
1797 :
1798 : /*
1799 : * quoteRelationName --- safely quote a fully qualified relation name
1800 : *
1801 : * buffer must be MAX_QUOTED_REL_NAME_LEN long (includes room for \0)
1802 : */
1803 : static void
1804 3500 : quoteRelationName(char *buffer, Relation rel)
1805 : {
1806 3500 : quoteOneName(buffer, get_namespace_name(RelationGetNamespace(rel)));
1807 3500 : buffer += strlen(buffer);
1808 3500 : *buffer++ = '.';
1809 3500 : quoteOneName(buffer, RelationGetRelationName(rel));
1810 3500 : }
1811 :
1812 : /*
1813 : * ri_GenerateQual --- generate a WHERE clause equating two variables
1814 : *
1815 : * This basically appends " sep leftop op rightop" to buf, adding casts
1816 : * and schema qualification as needed to ensure that the parser will select
1817 : * the operator we specify. leftop and rightop should be parenthesized
1818 : * if they aren't variables or parameters.
1819 : */
1820 : static void
1821 3364 : ri_GenerateQual(StringInfo buf,
1822 : const char *sep,
1823 : const char *leftop, Oid leftoptype,
1824 : Oid opoid,
1825 : const char *rightop, Oid rightoptype)
1826 : {
1827 3364 : appendStringInfo(buf, " %s ", sep);
1828 3364 : generate_operator_clause(buf, leftop, leftoptype, opoid,
1829 : rightop, rightoptype);
1830 3364 : }
1831 :
1832 : /*
1833 : * ri_GenerateQualCollation --- add a COLLATE spec to a WHERE clause
1834 : *
1835 : * At present, we intentionally do not use this function for RI queries that
1836 : * compare a variable to a $n parameter. Since parameter symbols always have
1837 : * default collation, the effect will be to use the variable's collation.
1838 : * Now that is only strictly correct when testing the referenced column, since
1839 : * the SQL standard specifies that RI comparisons should use the referenced
1840 : * column's collation. However, so long as all collations have the same
1841 : * notion of equality (which they do, because texteq reduces to bitwise
1842 : * equality), there's no visible semantic impact from using the referencing
1843 : * column's collation when testing it, and this is a good thing to do because
1844 : * it lets us use a normal index on the referencing column. However, we do
1845 : * have to use this function when directly comparing the referencing and
1846 : * referenced columns, if they are of different collations; else the parser
1847 : * will fail to resolve the collation to use.
1848 : */
1849 : static void
1850 8 : ri_GenerateQualCollation(StringInfo buf, Oid collation)
1851 : {
1852 : HeapTuple tp;
1853 : Form_pg_collation colltup;
1854 : char *collname;
1855 : char onename[MAX_QUOTED_NAME_LEN];
1856 :
1857 : /* Nothing to do if it's a noncollatable data type */
1858 8 : if (!OidIsValid(collation))
1859 0 : return;
1860 :
1861 8 : tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collation));
1862 8 : if (!HeapTupleIsValid(tp))
1863 0 : elog(ERROR, "cache lookup failed for collation %u", collation);
1864 8 : colltup = (Form_pg_collation) GETSTRUCT(tp);
1865 8 : collname = NameStr(colltup->collname);
1866 :
1867 : /*
1868 : * We qualify the name always, for simplicity and to ensure the query is
1869 : * not search-path-dependent.
1870 : */
1871 8 : quoteOneName(onename, get_namespace_name(colltup->collnamespace));
1872 8 : appendStringInfo(buf, " COLLATE %s", onename);
1873 8 : quoteOneName(onename, collname);
1874 8 : appendStringInfo(buf, ".%s", onename);
1875 :
1876 8 : ReleaseSysCache(tp);
1877 : }
1878 :
1879 : /* ----------
1880 : * ri_BuildQueryKey -
1881 : *
1882 : * Construct a hashtable key for a prepared SPI plan of an FK constraint.
1883 : *
1884 : * key: output argument, *key is filled in based on the other arguments
1885 : * riinfo: info from pg_constraint entry
1886 : * constr_queryno: an internal number identifying the query type
1887 : * (see RI_PLAN_XXX constants at head of file)
1888 : * ----------
1889 : */
1890 : static void
1891 3738 : ri_BuildQueryKey(RI_QueryKey *key, const RI_ConstraintInfo *riinfo,
1892 : int32 constr_queryno)
1893 : {
1894 : /*
1895 : * We assume struct RI_QueryKey contains no padding bytes, else we'd need
1896 : * to use memset to clear them.
1897 : */
1898 3738 : key->constr_id = riinfo->constraint_id;
1899 3738 : key->constr_queryno = constr_queryno;
1900 3738 : }
1901 :
1902 : /*
1903 : * Check that RI trigger function was called in expected context
1904 : */
1905 : static void
1906 3466 : ri_CheckTrigger(FunctionCallInfo fcinfo, const char *funcname, int tgkind)
1907 : {
1908 3466 : TriggerData *trigdata = (TriggerData *) fcinfo->context;
1909 :
1910 3466 : if (!CALLED_AS_TRIGGER(fcinfo))
1911 0 : ereport(ERROR,
1912 : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
1913 : errmsg("function \"%s\" was not called by trigger manager", funcname)));
1914 :
1915 : /*
1916 : * Check proper event
1917 : */
1918 3466 : if (!TRIGGER_FIRED_AFTER(trigdata->tg_event) ||
1919 3466 : !TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
1920 0 : ereport(ERROR,
1921 : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
1922 : errmsg("function \"%s\" must be fired AFTER ROW", funcname)));
1923 :
1924 3466 : switch (tgkind)
1925 : {
1926 2576 : case RI_TRIGTYPE_INSERT:
1927 2576 : if (!TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
1928 0 : ereport(ERROR,
1929 : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
1930 : errmsg("function \"%s\" must be fired for INSERT", funcname)));
1931 2576 : break;
1932 482 : case RI_TRIGTYPE_UPDATE:
1933 482 : if (!TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
1934 0 : ereport(ERROR,
1935 : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
1936 : errmsg("function \"%s\" must be fired for UPDATE", funcname)));
1937 482 : break;
1938 408 : case RI_TRIGTYPE_DELETE:
1939 408 : if (!TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
1940 0 : ereport(ERROR,
1941 : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
1942 : errmsg("function \"%s\" must be fired for DELETE", funcname)));
1943 408 : break;
1944 : }
1945 3466 : }
1946 :
1947 :
1948 : /*
1949 : * Fetch the RI_ConstraintInfo struct for the trigger's FK constraint.
1950 : */
1951 : static const RI_ConstraintInfo *
1952 6058 : ri_FetchConstraintInfo(Trigger *trigger, Relation trig_rel, bool rel_is_pk)
1953 : {
1954 6058 : Oid constraintOid = trigger->tgconstraint;
1955 : const RI_ConstraintInfo *riinfo;
1956 :
1957 : /*
1958 : * Check that the FK constraint's OID is available; it might not be if
1959 : * we've been invoked via an ordinary trigger or an old-style "constraint
1960 : * trigger".
1961 : */
1962 6058 : if (!OidIsValid(constraintOid))
1963 0 : ereport(ERROR,
1964 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
1965 : errmsg("no pg_constraint entry for trigger \"%s\" on table \"%s\"",
1966 : trigger->tgname, RelationGetRelationName(trig_rel)),
1967 : errhint("Remove this referential integrity trigger and its mates, then do ALTER TABLE ADD CONSTRAINT.")));
1968 :
1969 : /* Find or create a hashtable entry for the constraint */
1970 6058 : riinfo = ri_LoadConstraintInfo(constraintOid);
1971 :
1972 : /* Do some easy cross-checks against the trigger call data */
1973 6058 : if (rel_is_pk)
1974 : {
1975 1928 : if (riinfo->fk_relid != trigger->tgconstrrelid ||
1976 1928 : riinfo->pk_relid != RelationGetRelid(trig_rel))
1977 0 : elog(ERROR, "wrong pg_constraint entry for trigger \"%s\" on table \"%s\"",
1978 : trigger->tgname, RelationGetRelationName(trig_rel));
1979 : }
1980 : else
1981 : {
1982 4130 : if (riinfo->fk_relid != RelationGetRelid(trig_rel) ||
1983 4130 : riinfo->pk_relid != trigger->tgconstrrelid)
1984 0 : elog(ERROR, "wrong pg_constraint entry for trigger \"%s\" on table \"%s\"",
1985 : trigger->tgname, RelationGetRelationName(trig_rel));
1986 : }
1987 :
1988 6058 : if (riinfo->confmatchtype != FKCONSTR_MATCH_FULL &&
1989 5748 : riinfo->confmatchtype != FKCONSTR_MATCH_PARTIAL &&
1990 5748 : riinfo->confmatchtype != FKCONSTR_MATCH_SIMPLE)
1991 0 : elog(ERROR, "unrecognized confmatchtype: %d",
1992 : riinfo->confmatchtype);
1993 :
1994 6058 : if (riinfo->confmatchtype == FKCONSTR_MATCH_PARTIAL)
1995 0 : ereport(ERROR,
1996 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1997 : errmsg("MATCH PARTIAL not yet implemented")));
1998 :
1999 6058 : return riinfo;
2000 : }
2001 :
2002 : /*
2003 : * Fetch or create the RI_ConstraintInfo struct for an FK constraint.
2004 : */
2005 : static const RI_ConstraintInfo *
2006 6058 : ri_LoadConstraintInfo(Oid constraintOid)
2007 : {
2008 : RI_ConstraintInfo *riinfo;
2009 : bool found;
2010 : HeapTuple tup;
2011 : Form_pg_constraint conForm;
2012 :
2013 : /*
2014 : * On the first call initialize the hashtable
2015 : */
2016 6058 : if (!ri_constraint_cache)
2017 344 : ri_InitHashTables();
2018 :
2019 : /*
2020 : * Find or create a hash entry. If we find a valid one, just return it.
2021 : */
2022 6058 : riinfo = (RI_ConstraintInfo *) hash_search(ri_constraint_cache,
2023 : (void *) &constraintOid,
2024 : HASH_ENTER, &found);
2025 6058 : if (!found)
2026 2776 : riinfo->valid = false;
2027 3282 : else if (riinfo->valid)
2028 3198 : return riinfo;
2029 :
2030 : /*
2031 : * Fetch the pg_constraint row so we can fill in the entry.
2032 : */
2033 2860 : tup = SearchSysCache1(CONSTROID, ObjectIdGetDatum(constraintOid));
2034 2860 : if (!HeapTupleIsValid(tup)) /* should not happen */
2035 0 : elog(ERROR, "cache lookup failed for constraint %u", constraintOid);
2036 2860 : conForm = (Form_pg_constraint) GETSTRUCT(tup);
2037 :
2038 2860 : if (conForm->contype != CONSTRAINT_FOREIGN) /* should not happen */
2039 0 : elog(ERROR, "constraint %u is not a foreign key constraint",
2040 : constraintOid);
2041 :
2042 : /* And extract data */
2043 : Assert(riinfo->constraint_id == constraintOid);
2044 2860 : riinfo->oidHashValue = GetSysCacheHashValue1(CONSTROID,
2045 : ObjectIdGetDatum(constraintOid));
2046 2860 : memcpy(&riinfo->conname, &conForm->conname, sizeof(NameData));
2047 2860 : riinfo->pk_relid = conForm->confrelid;
2048 2860 : riinfo->fk_relid = conForm->conrelid;
2049 2860 : riinfo->confupdtype = conForm->confupdtype;
2050 2860 : riinfo->confdeltype = conForm->confdeltype;
2051 2860 : riinfo->confmatchtype = conForm->confmatchtype;
2052 :
2053 2860 : DeconstructFkConstraintRow(tup,
2054 : &riinfo->nkeys,
2055 2860 : riinfo->fk_attnums,
2056 2860 : riinfo->pk_attnums,
2057 2860 : riinfo->pf_eq_oprs,
2058 2860 : riinfo->pp_eq_oprs,
2059 2860 : riinfo->ff_eq_oprs);
2060 :
2061 2860 : ReleaseSysCache(tup);
2062 :
2063 : /*
2064 : * For efficient processing of invalidation messages below, we keep a
2065 : * doubly-linked list, and a count, of all currently valid entries.
2066 : */
2067 2860 : dlist_push_tail(&ri_constraint_cache_valid_list, &riinfo->valid_link);
2068 2860 : ri_constraint_cache_valid_count++;
2069 :
2070 2860 : riinfo->valid = true;
2071 :
2072 2860 : return riinfo;
2073 : }
2074 :
2075 : /*
2076 : * Callback for pg_constraint inval events
2077 : *
2078 : * While most syscache callbacks just flush all their entries, pg_constraint
2079 : * gets enough update traffic that it's probably worth being smarter.
2080 : * Invalidate any ri_constraint_cache entry associated with the syscache
2081 : * entry with the specified hash value, or all entries if hashvalue == 0.
2082 : *
2083 : * Note: at the time a cache invalidation message is processed there may be
2084 : * active references to the cache. Because of this we never remove entries
2085 : * from the cache, but only mark them invalid, which is harmless to active
2086 : * uses. (Any query using an entry should hold a lock sufficient to keep that
2087 : * data from changing under it --- but we may get cache flushes anyway.)
2088 : */
2089 : static void
2090 19002 : InvalidateConstraintCacheCallBack(Datum arg, int cacheid, uint32 hashvalue)
2091 : {
2092 : dlist_mutable_iter iter;
2093 :
2094 : Assert(ri_constraint_cache != NULL);
2095 :
2096 : /*
2097 : * If the list of currently valid entries gets excessively large, we mark
2098 : * them all invalid so we can empty the list. This arrangement avoids
2099 : * O(N^2) behavior in situations where a session touches many foreign keys
2100 : * and also does many ALTER TABLEs, such as a restore from pg_dump.
2101 : */
2102 19002 : if (ri_constraint_cache_valid_count > 1000)
2103 0 : hashvalue = 0; /* pretend it's a cache reset */
2104 :
2105 57162 : dlist_foreach_modify(iter, &ri_constraint_cache_valid_list)
2106 : {
2107 38160 : RI_ConstraintInfo *riinfo = dlist_container(RI_ConstraintInfo,
2108 : valid_link, iter.cur);
2109 :
2110 38160 : if (hashvalue == 0 || riinfo->oidHashValue == hashvalue)
2111 : {
2112 1594 : riinfo->valid = false;
2113 : /* Remove invalidated entries from the list, too */
2114 1594 : dlist_delete(iter.cur);
2115 1594 : ri_constraint_cache_valid_count--;
2116 : }
2117 : }
2118 19002 : }
2119 :
2120 :
2121 : /*
2122 : * Prepare execution plan for a query to enforce an RI restriction
2123 : *
2124 : * If cache_plan is true, the plan is saved into our plan hashtable
2125 : * so that we don't need to plan it again.
2126 : */
2127 : static SPIPlanPtr
2128 2192 : ri_PlanCheck(const char *querystr, int nargs, Oid *argtypes,
2129 : RI_QueryKey *qkey, Relation fk_rel, Relation pk_rel)
2130 : {
2131 : SPIPlanPtr qplan;
2132 : Relation query_rel;
2133 : Oid save_userid;
2134 : int save_sec_context;
2135 :
2136 : /*
2137 : * Use the query type code to determine whether the query is run against
2138 : * the PK or FK table; we'll do the check as that table's owner
2139 : */
2140 2192 : if (qkey->constr_queryno <= RI_PLAN_LAST_ON_PK)
2141 1818 : query_rel = pk_rel;
2142 : else
2143 374 : query_rel = fk_rel;
2144 :
2145 : /* Switch to proper UID to perform check as */
2146 2192 : GetUserIdAndSecContext(&save_userid, &save_sec_context);
2147 2192 : SetUserIdAndSecContext(RelationGetForm(query_rel)->relowner,
2148 : save_sec_context | SECURITY_LOCAL_USERID_CHANGE |
2149 : SECURITY_NOFORCE_RLS);
2150 :
2151 : /* Create the plan */
2152 2192 : qplan = SPI_prepare(querystr, nargs, argtypes);
2153 :
2154 2192 : if (qplan == NULL)
2155 0 : elog(ERROR, "SPI_prepare returned %s for %s", SPI_result_code_string(SPI_result), querystr);
2156 :
2157 : /* Restore UID and security context */
2158 2192 : SetUserIdAndSecContext(save_userid, save_sec_context);
2159 :
2160 : /* Save the plan */
2161 2192 : SPI_keepplan(qplan);
2162 2192 : ri_HashPreparedPlan(qkey, qplan);
2163 :
2164 2192 : return qplan;
2165 : }
2166 :
2167 : /*
2168 : * Perform a query to enforce an RI restriction
2169 : */
2170 : static bool
2171 3738 : ri_PerformCheck(const RI_ConstraintInfo *riinfo,
2172 : RI_QueryKey *qkey, SPIPlanPtr qplan,
2173 : Relation fk_rel, Relation pk_rel,
2174 : TupleTableSlot *oldslot, TupleTableSlot *newslot,
2175 : bool detectNewRows, int expect_OK)
2176 : {
2177 : Relation query_rel,
2178 : source_rel;
2179 : bool source_is_pk;
2180 : Snapshot test_snapshot;
2181 : Snapshot crosscheck_snapshot;
2182 : int limit;
2183 : int spi_result;
2184 : Oid save_userid;
2185 : int save_sec_context;
2186 : Datum vals[RI_MAX_NUMKEYS * 2];
2187 : char nulls[RI_MAX_NUMKEYS * 2];
2188 :
2189 : /*
2190 : * Use the query type code to determine whether the query is run against
2191 : * the PK or FK table; we'll do the check as that table's owner
2192 : */
2193 3738 : if (qkey->constr_queryno <= RI_PLAN_LAST_ON_PK)
2194 3006 : query_rel = pk_rel;
2195 : else
2196 732 : query_rel = fk_rel;
2197 :
2198 : /*
2199 : * The values for the query are taken from the table on which the trigger
2200 : * is called - it is normally the other one with respect to query_rel. An
2201 : * exception is ri_Check_Pk_Match(), which uses the PK table for both (and
2202 : * sets queryno to RI_PLAN_CHECK_LOOKUPPK_FROM_PK). We might eventually
2203 : * need some less klugy way to determine this.
2204 : */
2205 3738 : if (qkey->constr_queryno == RI_PLAN_CHECK_LOOKUPPK)
2206 : {
2207 2566 : source_rel = fk_rel;
2208 2566 : source_is_pk = false;
2209 : }
2210 : else
2211 : {
2212 1172 : source_rel = pk_rel;
2213 1172 : source_is_pk = true;
2214 : }
2215 :
2216 : /* Extract the parameters to be passed into the query */
2217 3738 : if (newslot)
2218 : {
2219 2622 : ri_ExtractValues(source_rel, newslot, riinfo, source_is_pk,
2220 : vals, nulls);
2221 2622 : if (oldslot)
2222 112 : ri_ExtractValues(source_rel, oldslot, riinfo, source_is_pk,
2223 56 : vals + riinfo->nkeys, nulls + riinfo->nkeys);
2224 : }
2225 : else
2226 : {
2227 1116 : ri_ExtractValues(source_rel, oldslot, riinfo, source_is_pk,
2228 : vals, nulls);
2229 : }
2230 :
2231 : /*
2232 : * In READ COMMITTED mode, we just need to use an up-to-date regular
2233 : * snapshot, and we will see all rows that could be interesting. But in
2234 : * transaction-snapshot mode, we can't change the transaction snapshot. If
2235 : * the caller passes detectNewRows == false then it's okay to do the query
2236 : * with the transaction snapshot; otherwise we use a current snapshot, and
2237 : * tell the executor to error out if it finds any rows under the current
2238 : * snapshot that wouldn't be visible per the transaction snapshot. Note
2239 : * that SPI_execute_snapshot will register the snapshots, so we don't need
2240 : * to bother here.
2241 : */
2242 3738 : if (IsolationUsesXactSnapshot() && detectNewRows)
2243 : {
2244 0 : CommandCounterIncrement(); /* be sure all my own work is visible */
2245 0 : test_snapshot = GetLatestSnapshot();
2246 0 : crosscheck_snapshot = GetTransactionSnapshot();
2247 : }
2248 : else
2249 : {
2250 : /* the default SPI behavior is okay */
2251 3738 : test_snapshot = InvalidSnapshot;
2252 3738 : crosscheck_snapshot = InvalidSnapshot;
2253 : }
2254 :
2255 : /*
2256 : * If this is a select query (e.g., for a 'no action' or 'restrict'
2257 : * trigger), we only need to see if there is a single row in the table,
2258 : * matching the key. Otherwise, limit = 0 - because we want the query to
2259 : * affect ALL the matching rows.
2260 : */
2261 3738 : limit = (expect_OK == SPI_OK_SELECT) ? 1 : 0;
2262 :
2263 : /* Switch to proper UID to perform check as */
2264 3738 : GetUserIdAndSecContext(&save_userid, &save_sec_context);
2265 3738 : SetUserIdAndSecContext(RelationGetForm(query_rel)->relowner,
2266 : save_sec_context | SECURITY_LOCAL_USERID_CHANGE |
2267 : SECURITY_NOFORCE_RLS);
2268 :
2269 : /* Finally we can run the query. */
2270 3738 : spi_result = SPI_execute_snapshot(qplan,
2271 : vals, nulls,
2272 : test_snapshot, crosscheck_snapshot,
2273 : false, false, limit);
2274 :
2275 : /* Restore UID and security context */
2276 3728 : SetUserIdAndSecContext(save_userid, save_sec_context);
2277 :
2278 : /* Check result */
2279 3728 : if (spi_result < 0)
2280 0 : elog(ERROR, "SPI_execute_snapshot returned %s", SPI_result_code_string(spi_result));
2281 :
2282 3728 : if (expect_OK >= 0 && spi_result != expect_OK)
2283 0 : ereport(ERROR,
2284 : (errcode(ERRCODE_INTERNAL_ERROR),
2285 : errmsg("referential integrity query on \"%s\" from constraint \"%s\" on \"%s\" gave unexpected result",
2286 : RelationGetRelationName(pk_rel),
2287 : NameStr(riinfo->conname),
2288 : RelationGetRelationName(fk_rel)),
2289 : errhint("This is most likely due to a rule having rewritten the query.")));
2290 :
2291 : /* XXX wouldn't it be clearer to do this part at the caller? */
2292 3728 : if (qkey->constr_queryno != RI_PLAN_CHECK_LOOKUPPK_FROM_PK &&
2293 3008 : expect_OK == SPI_OK_SELECT &&
2294 3008 : (SPI_processed == 0) == (qkey->constr_queryno == RI_PLAN_CHECK_LOOKUPPK))
2295 472 : ri_ReportViolation(riinfo,
2296 : pk_rel, fk_rel,
2297 : newslot ? newslot : oldslot,
2298 : NULL,
2299 : qkey->constr_queryno, false);
2300 :
2301 3256 : return SPI_processed != 0;
2302 : }
2303 :
2304 : /*
2305 : * Extract fields from a tuple into Datum/nulls arrays
2306 : */
2307 : static void
2308 3794 : ri_ExtractValues(Relation rel, TupleTableSlot *slot,
2309 : const RI_ConstraintInfo *riinfo, bool rel_is_pk,
2310 : Datum *vals, char *nulls)
2311 : {
2312 : const int16 *attnums;
2313 : bool isnull;
2314 :
2315 3794 : if (rel_is_pk)
2316 1228 : attnums = riinfo->pk_attnums;
2317 : else
2318 2566 : attnums = riinfo->fk_attnums;
2319 :
2320 8548 : for (int i = 0; i < riinfo->nkeys; i++)
2321 : {
2322 4754 : vals[i] = slot_getattr(slot, attnums[i], &isnull);
2323 4754 : nulls[i] = isnull ? 'n' : ' ';
2324 : }
2325 3794 : }
2326 :
2327 : /*
2328 : * Produce an error report
2329 : *
2330 : * If the failed constraint was on insert/update to the FK table,
2331 : * we want the key names and values extracted from there, and the error
2332 : * message to look like 'key blah is not present in PK'.
2333 : * Otherwise, the attr names and values come from the PK table and the
2334 : * message looks like 'key blah is still referenced from FK'.
2335 : */
2336 : static void
2337 526 : ri_ReportViolation(const RI_ConstraintInfo *riinfo,
2338 : Relation pk_rel, Relation fk_rel,
2339 : TupleTableSlot *violatorslot, TupleDesc tupdesc,
2340 : int queryno, bool partgone)
2341 : {
2342 : StringInfoData key_names;
2343 : StringInfoData key_values;
2344 : bool onfk;
2345 : const int16 *attnums;
2346 : Oid rel_oid;
2347 : AclResult aclresult;
2348 526 : bool has_perm = true;
2349 :
2350 : /*
2351 : * Determine which relation to complain about. If tupdesc wasn't passed
2352 : * by caller, assume the violator tuple came from there.
2353 : */
2354 526 : onfk = (queryno == RI_PLAN_CHECK_LOOKUPPK);
2355 526 : if (onfk)
2356 : {
2357 304 : attnums = riinfo->fk_attnums;
2358 304 : rel_oid = fk_rel->rd_id;
2359 304 : if (tupdesc == NULL)
2360 270 : tupdesc = fk_rel->rd_att;
2361 : }
2362 : else
2363 : {
2364 222 : attnums = riinfo->pk_attnums;
2365 222 : rel_oid = pk_rel->rd_id;
2366 222 : if (tupdesc == NULL)
2367 202 : tupdesc = pk_rel->rd_att;
2368 : }
2369 :
2370 : /*
2371 : * Check permissions- if the user does not have access to view the data in
2372 : * any of the key columns then we don't include the errdetail() below.
2373 : *
2374 : * Check if RLS is enabled on the relation first. If so, we don't return
2375 : * any specifics to avoid leaking data.
2376 : *
2377 : * Check table-level permissions next and, failing that, column-level
2378 : * privileges.
2379 : *
2380 : * When a partition at the referenced side is being detached/dropped, we
2381 : * needn't check, since the user must be the table owner anyway.
2382 : */
2383 526 : if (partgone)
2384 20 : has_perm = true;
2385 506 : else if (check_enable_rls(rel_oid, InvalidOid, true) != RLS_ENABLED)
2386 : {
2387 502 : aclresult = pg_class_aclcheck(rel_oid, GetUserId(), ACL_SELECT);
2388 502 : if (aclresult != ACLCHECK_OK)
2389 : {
2390 : /* Try for column-level permissions */
2391 0 : for (int idx = 0; idx < riinfo->nkeys; idx++)
2392 : {
2393 0 : aclresult = pg_attribute_aclcheck(rel_oid, attnums[idx],
2394 : GetUserId(),
2395 : ACL_SELECT);
2396 :
2397 : /* No access to the key */
2398 0 : if (aclresult != ACLCHECK_OK)
2399 : {
2400 0 : has_perm = false;
2401 0 : break;
2402 : }
2403 : }
2404 : }
2405 : }
2406 : else
2407 4 : has_perm = false;
2408 :
2409 526 : if (has_perm)
2410 : {
2411 : /* Get printable versions of the keys involved */
2412 522 : initStringInfo(&key_names);
2413 522 : initStringInfo(&key_values);
2414 1240 : for (int idx = 0; idx < riinfo->nkeys; idx++)
2415 : {
2416 718 : int fnum = attnums[idx];
2417 718 : Form_pg_attribute att = TupleDescAttr(tupdesc, fnum - 1);
2418 : char *name,
2419 : *val;
2420 : Datum datum;
2421 : bool isnull;
2422 :
2423 718 : name = NameStr(att->attname);
2424 :
2425 718 : datum = slot_getattr(violatorslot, fnum, &isnull);
2426 718 : if (!isnull)
2427 : {
2428 : Oid foutoid;
2429 : bool typisvarlena;
2430 :
2431 718 : getTypeOutputInfo(att->atttypid, &foutoid, &typisvarlena);
2432 718 : val = OidOutputFunctionCall(foutoid, datum);
2433 : }
2434 : else
2435 0 : val = "null";
2436 :
2437 718 : if (idx > 0)
2438 : {
2439 196 : appendStringInfoString(&key_names, ", ");
2440 196 : appendStringInfoString(&key_values, ", ");
2441 : }
2442 718 : appendStringInfoString(&key_names, name);
2443 718 : appendStringInfoString(&key_values, val);
2444 : }
2445 : }
2446 :
2447 526 : if (partgone)
2448 20 : ereport(ERROR,
2449 : (errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
2450 : errmsg("removing partition \"%s\" violates foreign key constraint \"%s\"",
2451 : RelationGetRelationName(pk_rel),
2452 : NameStr(riinfo->conname)),
2453 : errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
2454 : key_names.data, key_values.data,
2455 : RelationGetRelationName(fk_rel)),
2456 : errtableconstraint(fk_rel, NameStr(riinfo->conname))));
2457 506 : else if (onfk)
2458 304 : ereport(ERROR,
2459 : (errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
2460 : errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
2461 : RelationGetRelationName(fk_rel),
2462 : NameStr(riinfo->conname)),
2463 : has_perm ?
2464 : errdetail("Key (%s)=(%s) is not present in table \"%s\".",
2465 : key_names.data, key_values.data,
2466 : RelationGetRelationName(pk_rel)) :
2467 : errdetail("Key is not present in table \"%s\".",
2468 : RelationGetRelationName(pk_rel)),
2469 : errtableconstraint(fk_rel, NameStr(riinfo->conname))));
2470 : else
2471 202 : ereport(ERROR,
2472 : (errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
2473 : errmsg("update or delete on table \"%s\" violates foreign key constraint \"%s\" on table \"%s\"",
2474 : RelationGetRelationName(pk_rel),
2475 : NameStr(riinfo->conname),
2476 : RelationGetRelationName(fk_rel)),
2477 : has_perm ?
2478 : errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
2479 : key_names.data, key_values.data,
2480 : RelationGetRelationName(fk_rel)) :
2481 : errdetail("Key is still referenced from table \"%s\".",
2482 : RelationGetRelationName(fk_rel)),
2483 : errtableconstraint(fk_rel, NameStr(riinfo->conname))));
2484 : }
2485 :
2486 :
2487 : /*
2488 : * ri_NullCheck -
2489 : *
2490 : * Determine the NULL state of all key values in a tuple
2491 : *
2492 : * Returns one of RI_KEYS_ALL_NULL, RI_KEYS_NONE_NULL or RI_KEYS_SOME_NULL.
2493 : */
2494 : static int
2495 4628 : ri_NullCheck(TupleDesc tupDesc,
2496 : TupleTableSlot *slot,
2497 : const RI_ConstraintInfo *riinfo, bool rel_is_pk)
2498 : {
2499 : const int16 *attnums;
2500 4628 : bool allnull = true;
2501 4628 : bool nonenull = true;
2502 :
2503 4628 : if (rel_is_pk)
2504 1184 : attnums = riinfo->pk_attnums;
2505 : else
2506 3444 : attnums = riinfo->fk_attnums;
2507 :
2508 10264 : for (int i = 0; i < riinfo->nkeys; i++)
2509 : {
2510 5636 : if (slot_attisnull(slot, attnums[i]))
2511 336 : nonenull = false;
2512 : else
2513 5300 : allnull = false;
2514 : }
2515 :
2516 4628 : if (allnull)
2517 176 : return RI_KEYS_ALL_NULL;
2518 :
2519 4452 : if (nonenull)
2520 4340 : return RI_KEYS_NONE_NULL;
2521 :
2522 112 : return RI_KEYS_SOME_NULL;
2523 : }
2524 :
2525 :
2526 : /*
2527 : * ri_InitHashTables -
2528 : *
2529 : * Initialize our internal hash tables.
2530 : */
2531 : static void
2532 344 : ri_InitHashTables(void)
2533 : {
2534 : HASHCTL ctl;
2535 :
2536 344 : memset(&ctl, 0, sizeof(ctl));
2537 344 : ctl.keysize = sizeof(Oid);
2538 344 : ctl.entrysize = sizeof(RI_ConstraintInfo);
2539 344 : ri_constraint_cache = hash_create("RI constraint cache",
2540 : RI_INIT_CONSTRAINTHASHSIZE,
2541 : &ctl, HASH_ELEM | HASH_BLOBS);
2542 :
2543 : /* Arrange to flush cache on pg_constraint changes */
2544 344 : CacheRegisterSyscacheCallback(CONSTROID,
2545 : InvalidateConstraintCacheCallBack,
2546 : (Datum) 0);
2547 :
2548 344 : memset(&ctl, 0, sizeof(ctl));
2549 344 : ctl.keysize = sizeof(RI_QueryKey);
2550 344 : ctl.entrysize = sizeof(RI_QueryHashEntry);
2551 344 : ri_query_cache = hash_create("RI query cache",
2552 : RI_INIT_QUERYHASHSIZE,
2553 : &ctl, HASH_ELEM | HASH_BLOBS);
2554 :
2555 344 : memset(&ctl, 0, sizeof(ctl));
2556 344 : ctl.keysize = sizeof(RI_CompareKey);
2557 344 : ctl.entrysize = sizeof(RI_CompareHashEntry);
2558 344 : ri_compare_cache = hash_create("RI compare cache",
2559 : RI_INIT_QUERYHASHSIZE,
2560 : &ctl, HASH_ELEM | HASH_BLOBS);
2561 344 : }
2562 :
2563 :
2564 : /*
2565 : * ri_FetchPreparedPlan -
2566 : *
2567 : * Lookup for a query key in our private hash table of prepared
2568 : * and saved SPI execution plans. Return the plan if found or NULL.
2569 : */
2570 : static SPIPlanPtr
2571 3738 : ri_FetchPreparedPlan(RI_QueryKey *key)
2572 : {
2573 : RI_QueryHashEntry *entry;
2574 : SPIPlanPtr plan;
2575 :
2576 : /*
2577 : * On the first call initialize the hashtable
2578 : */
2579 3738 : if (!ri_query_cache)
2580 0 : ri_InitHashTables();
2581 :
2582 : /*
2583 : * Lookup for the key
2584 : */
2585 3738 : entry = (RI_QueryHashEntry *) hash_search(ri_query_cache,
2586 : (void *) key,
2587 : HASH_FIND, NULL);
2588 3738 : if (entry == NULL)
2589 2034 : return NULL;
2590 :
2591 : /*
2592 : * Check whether the plan is still valid. If it isn't, we don't want to
2593 : * simply rely on plancache.c to regenerate it; rather we should start
2594 : * from scratch and rebuild the query text too. This is to cover cases
2595 : * such as table/column renames. We depend on the plancache machinery to
2596 : * detect possible invalidations, though.
2597 : *
2598 : * CAUTION: this check is only trustworthy if the caller has already
2599 : * locked both FK and PK rels.
2600 : */
2601 1704 : plan = entry->plan;
2602 1704 : if (plan && SPI_plan_is_valid(plan))
2603 1546 : return plan;
2604 :
2605 : /*
2606 : * Otherwise we might as well flush the cached plan now, to free a little
2607 : * memory space before we make a new one.
2608 : */
2609 158 : entry->plan = NULL;
2610 158 : if (plan)
2611 158 : SPI_freeplan(plan);
2612 :
2613 158 : return NULL;
2614 : }
2615 :
2616 :
2617 : /*
2618 : * ri_HashPreparedPlan -
2619 : *
2620 : * Add another plan to our private SPI query plan hashtable.
2621 : */
2622 : static void
2623 2192 : ri_HashPreparedPlan(RI_QueryKey *key, SPIPlanPtr plan)
2624 : {
2625 : RI_QueryHashEntry *entry;
2626 : bool found;
2627 :
2628 : /*
2629 : * On the first call initialize the hashtable
2630 : */
2631 2192 : if (!ri_query_cache)
2632 0 : ri_InitHashTables();
2633 :
2634 : /*
2635 : * Add the new plan. We might be overwriting an entry previously found
2636 : * invalid by ri_FetchPreparedPlan.
2637 : */
2638 2192 : entry = (RI_QueryHashEntry *) hash_search(ri_query_cache,
2639 : (void *) key,
2640 : HASH_ENTER, &found);
2641 : Assert(!found || entry->plan == NULL);
2642 2192 : entry->plan = plan;
2643 2192 : }
2644 :
2645 :
2646 : /*
2647 : * ri_KeysEqual -
2648 : *
2649 : * Check if all key values in OLD and NEW are equal.
2650 : *
2651 : * Note: at some point we might wish to redefine this as checking for
2652 : * "IS NOT DISTINCT" rather than "=", that is, allow two nulls to be
2653 : * considered equal. Currently there is no need since all callers have
2654 : * previously found at least one of the rows to contain no nulls.
2655 : */
2656 : static bool
2657 1240 : ri_KeysEqual(Relation rel, TupleTableSlot *oldslot, TupleTableSlot *newslot,
2658 : const RI_ConstraintInfo *riinfo, bool rel_is_pk)
2659 : {
2660 : const int16 *attnums;
2661 :
2662 1240 : if (rel_is_pk)
2663 748 : attnums = riinfo->pk_attnums;
2664 : else
2665 492 : attnums = riinfo->fk_attnums;
2666 :
2667 : /* XXX: could be worthwhile to fetch all necessary attrs at once */
2668 2160 : for (int i = 0; i < riinfo->nkeys; i++)
2669 : {
2670 : Datum oldvalue;
2671 : Datum newvalue;
2672 : bool isnull;
2673 :
2674 : /*
2675 : * Get one attribute's oldvalue. If it is NULL - they're not equal.
2676 : */
2677 1316 : oldvalue = slot_getattr(oldslot, attnums[i], &isnull);
2678 1316 : if (isnull)
2679 396 : return false;
2680 :
2681 : /*
2682 : * Get one attribute's newvalue. If it is NULL - they're not equal.
2683 : */
2684 1292 : newvalue = slot_getattr(newslot, attnums[i], &isnull);
2685 1292 : if (isnull)
2686 0 : return false;
2687 :
2688 1292 : if (rel_is_pk)
2689 : {
2690 : /*
2691 : * If we are looking at the PK table, then do a bytewise
2692 : * comparison. We must propagate PK changes if the value is
2693 : * changed to one that "looks" different but would compare as
2694 : * equal using the equality operator. This only makes a
2695 : * difference for ON UPDATE CASCADE, but for consistency we treat
2696 : * all changes to the PK the same.
2697 : */
2698 804 : Form_pg_attribute att = TupleDescAttr(oldslot->tts_tupleDescriptor, attnums[i] - 1);
2699 :
2700 804 : if (!datum_image_eq(oldvalue, newvalue, att->attbyval, att->attlen))
2701 276 : return false;
2702 : }
2703 : else
2704 : {
2705 : /*
2706 : * For the FK table, compare with the appropriate equality
2707 : * operator. Changes that compare equal will still satisfy the
2708 : * constraint after the update.
2709 : */
2710 488 : if (!ri_AttributesEqual(riinfo->ff_eq_oprs[i], RIAttType(rel, attnums[i]),
2711 : oldvalue, newvalue))
2712 96 : return false;
2713 : }
2714 : }
2715 :
2716 844 : return true;
2717 : }
2718 :
2719 :
2720 : /*
2721 : * ri_AttributesEqual -
2722 : *
2723 : * Call the appropriate equality comparison operator for two values.
2724 : *
2725 : * NB: we have already checked that neither value is null.
2726 : */
2727 : static bool
2728 488 : ri_AttributesEqual(Oid eq_opr, Oid typeid,
2729 : Datum oldvalue, Datum newvalue)
2730 : {
2731 488 : RI_CompareHashEntry *entry = ri_HashCompareOp(eq_opr, typeid);
2732 :
2733 : /* Do we need to cast the values? */
2734 488 : if (OidIsValid(entry->cast_func_finfo.fn_oid))
2735 : {
2736 8 : oldvalue = FunctionCall3(&entry->cast_func_finfo,
2737 : oldvalue,
2738 : Int32GetDatum(-1), /* typmod */
2739 : BoolGetDatum(false)); /* implicit coercion */
2740 8 : newvalue = FunctionCall3(&entry->cast_func_finfo,
2741 : newvalue,
2742 : Int32GetDatum(-1), /* typmod */
2743 : BoolGetDatum(false)); /* implicit coercion */
2744 : }
2745 :
2746 : /*
2747 : * Apply the comparison operator.
2748 : *
2749 : * Note: This function is part of a call stack that determines whether an
2750 : * update to a row is significant enough that it needs checking or action
2751 : * on the other side of a foreign-key constraint. Therefore, the
2752 : * comparison here would need to be done with the collation of the *other*
2753 : * table. For simplicity (e.g., we might not even have the other table
2754 : * open), we'll just use the default collation here, which could lead to
2755 : * some false negatives. All this would break if we ever allow
2756 : * database-wide collations to be nondeterministic.
2757 : */
2758 488 : return DatumGetBool(FunctionCall2Coll(&entry->eq_opr_finfo,
2759 : DEFAULT_COLLATION_OID,
2760 : oldvalue, newvalue));
2761 : }
2762 :
2763 : /*
2764 : * ri_HashCompareOp -
2765 : *
2766 : * See if we know how to compare two values, and create a new hash entry
2767 : * if not.
2768 : */
2769 : static RI_CompareHashEntry *
2770 488 : ri_HashCompareOp(Oid eq_opr, Oid typeid)
2771 : {
2772 : RI_CompareKey key;
2773 : RI_CompareHashEntry *entry;
2774 : bool found;
2775 :
2776 : /*
2777 : * On the first call initialize the hashtable
2778 : */
2779 488 : if (!ri_compare_cache)
2780 0 : ri_InitHashTables();
2781 :
2782 : /*
2783 : * Find or create a hash entry. Note we're assuming RI_CompareKey
2784 : * contains no struct padding.
2785 : */
2786 488 : key.eq_opr = eq_opr;
2787 488 : key.typeid = typeid;
2788 488 : entry = (RI_CompareHashEntry *) hash_search(ri_compare_cache,
2789 : (void *) &key,
2790 : HASH_ENTER, &found);
2791 488 : if (!found)
2792 248 : entry->valid = false;
2793 :
2794 : /*
2795 : * If not already initialized, do so. Since we'll keep this hash entry
2796 : * for the life of the backend, put any subsidiary info for the function
2797 : * cache structs into TopMemoryContext.
2798 : */
2799 488 : if (!entry->valid)
2800 : {
2801 : Oid lefttype,
2802 : righttype,
2803 : castfunc;
2804 : CoercionPathType pathtype;
2805 :
2806 : /* We always need to know how to call the equality operator */
2807 248 : fmgr_info_cxt(get_opcode(eq_opr), &entry->eq_opr_finfo,
2808 : TopMemoryContext);
2809 :
2810 : /*
2811 : * If we chose to use a cast from FK to PK type, we may have to apply
2812 : * the cast function to get to the operator's input type.
2813 : *
2814 : * XXX eventually it would be good to support array-coercion cases
2815 : * here and in ri_AttributesEqual(). At the moment there is no point
2816 : * because cases involving nonidentical array types will be rejected
2817 : * at constraint creation time.
2818 : *
2819 : * XXX perhaps also consider supporting CoerceViaIO? No need at the
2820 : * moment since that will never be generated for implicit coercions.
2821 : */
2822 248 : op_input_types(eq_opr, &lefttype, &righttype);
2823 : Assert(lefttype == righttype);
2824 248 : if (typeid == lefttype)
2825 244 : castfunc = InvalidOid; /* simplest case */
2826 : else
2827 : {
2828 4 : pathtype = find_coercion_pathway(lefttype, typeid,
2829 : COERCION_IMPLICIT,
2830 : &castfunc);
2831 4 : if (pathtype != COERCION_PATH_FUNC &&
2832 : pathtype != COERCION_PATH_RELABELTYPE)
2833 : {
2834 : /*
2835 : * The declared input type of the eq_opr might be a
2836 : * polymorphic type such as ANYARRAY or ANYENUM, or other
2837 : * special cases such as RECORD; find_coercion_pathway
2838 : * currently doesn't subsume these special cases.
2839 : */
2840 0 : if (!IsBinaryCoercible(typeid, lefttype))
2841 0 : elog(ERROR, "no conversion function from %s to %s",
2842 : format_type_be(typeid),
2843 : format_type_be(lefttype));
2844 : }
2845 : }
2846 248 : if (OidIsValid(castfunc))
2847 4 : fmgr_info_cxt(castfunc, &entry->cast_func_finfo,
2848 : TopMemoryContext);
2849 : else
2850 244 : entry->cast_func_finfo.fn_oid = InvalidOid;
2851 248 : entry->valid = true;
2852 : }
2853 :
2854 488 : return entry;
2855 : }
2856 :
2857 :
2858 : /*
2859 : * Given a trigger function OID, determine whether it is an RI trigger,
2860 : * and if so whether it is attached to PK or FK relation.
2861 : */
2862 : int
2863 3542 : RI_FKey_trigger_type(Oid tgfoid)
2864 : {
2865 3542 : switch (tgfoid)
2866 : {
2867 1184 : case F_RI_FKEY_CASCADE_DEL:
2868 : case F_RI_FKEY_CASCADE_UPD:
2869 : case F_RI_FKEY_RESTRICT_DEL:
2870 : case F_RI_FKEY_RESTRICT_UPD:
2871 : case F_RI_FKEY_SETNULL_DEL:
2872 : case F_RI_FKEY_SETNULL_UPD:
2873 : case F_RI_FKEY_SETDEFAULT_DEL:
2874 : case F_RI_FKEY_SETDEFAULT_UPD:
2875 : case F_RI_FKEY_NOACTION_DEL:
2876 : case F_RI_FKEY_NOACTION_UPD:
2877 1184 : return RI_TRIGGER_PK;
2878 :
2879 678 : case F_RI_FKEY_CHECK_INS:
2880 : case F_RI_FKEY_CHECK_UPD:
2881 678 : return RI_TRIGGER_FK;
2882 : }
2883 :
2884 1680 : return RI_TRIGGER_NONE;
2885 : }
|
