| blob | 35eb7180f7eb9d2860d9287d33eb5e889b0d9d93 |
1 /*-------------------------------------------------------------------------
2 *
3 * trigger.c
4 * PostgreSQL TRIGGERs support code.
5 *
6 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 * IDENTIFICATION
10 * src/backend/commands/trigger.c
11 *
12 *-------------------------------------------------------------------------
13 */
62 /* GUC variables */
65 /* How many levels deep into trigger execution are we? */
68 /* Local function prototypes */
79 ItemPointer tid,
80 LockTupleMode lockmode,
93 MemoryContext per_tuple_context);
106 /*
107 * Create a trigger. Returns the address of the created trigger.
108 *
109 * queryString is the source text of the CREATE TRIGGER command.
110 * This must be supplied if a whenClause is specified, else it can be NULL.
111 *
112 * relOid, if nonzero, is the relation on which the trigger should be
113 * created. If zero, the name provided in the statement will be looked up.
114 *
115 * refRelOid, if nonzero, is the relation to which the constraint trigger
116 * refers. If zero, the constraint relation name provided in the statement
117 * will be looked up as needed.
118 *
119 * constraintOid, if nonzero, says that this trigger is being created
120 * internally to implement that constraint. A suitable pg_depend entry will
121 * be made to link the trigger to that constraint. constraintOid is zero when
122 * executing a user-entered CREATE TRIGGER command. (For CREATE CONSTRAINT
123 * TRIGGER, we build a pg_constraint entry internally.)
124 *
125 * indexOid, if nonzero, is the OID of an index associated with the constraint.
126 * We do nothing with this except store it into pg_trigger.tgconstrindid;
127 * but when creating a trigger for a deferrable unique constraint on a
128 * partitioned table, its children are looked up. Note we don't cope with
129 * invalid indexes in that case.
130 *
131 * funcoid, if nonzero, is the OID of the function to invoke. When this is
132 * given, stmt->funcname is ignored.
133 *
134 * parentTriggerOid, if nonzero, is a trigger that begets this one; so that
135 * if that trigger is dropped, this one should be too. There are two cases
136 * when a nonzero value is passed for this: 1) when this function recurses to
137 * create the trigger on partitions, 2) when creating child foreign key
138 * triggers; see CreateFKCheckTrigger() and createForeignKeyActionTriggers().
139 *
140 * If whenClause is passed, it is an already-transformed expression for
141 * WHEN. In this case, we ignore any that may come in stmt->whenClause.
142 *
143 * If isInternal is true then this is an internally-generated trigger.
144 * This argument sets the tgisinternal field of the pg_trigger entry, and
145 * if true causes us to modify the given trigger name to ensure uniqueness.
146 *
147 * When isInternal is not true we require ACL_TRIGGER permissions on the
148 * relation, as well as ACL_EXECUTE on the trigger function. For internal
149 * triggers the caller must apply any required permission checks.
150 *
151 * When called on partitioned tables, this function recurses to create the
152 * trigger on all the partitions, except if isInternal is true, in which
153 * case caller is expected to execute recursion on its own. in_partition
154 * indicates such a recursive call; outside callers should pass "false"
155 * (but see CloneRowTriggersToPartition).
156 */
157 ObjectAddress
162 {
163 return
168 }
170 /*
171 * Like the above; additionally the firing condition
172 * (always/origin/replica/disabled) can be specified.
173 */
174 ObjectAddress
180 {
181 int16 tgtype;
189 Relation rel;
190 AclResult aclresult;
191 Relation tgrel;
192 Relation pgrel;
194 Oid funcrettype;
199 ObjectAddress myself,
200 referenced;
211 else
214 /*
215 * Triggers must be on tables or views, and there are additional
216 * relation-type-specific restrictions.
217 */
219 {
220 /* Tables can't have INSTEAD OF triggers */
228 }
230 {
231 /* Partitioned tables can't have INSTEAD OF triggers */
240 /*
241 * FOR EACH ROW triggers have further restrictions
242 */
244 {
245 /*
246 * Disallow use of transition tables.
247 *
248 * Note that we have another restriction about transition tables
249 * in partitions; search for 'has_superclass' below for an
250 * explanation. The check here is just to protect from the fact
251 * that if we allowed it here, the creation would succeed for a
252 * partitioned table with no partitions, but would be blocked by
253 * the other restriction when the first partition was created,
254 * which is very unfriendly behavior.
255 */
262 }
263 }
265 {
266 /*
267 * Views can have INSTEAD OF triggers (which we check below are
268 * row-level), or statement-level BEFORE/AFTER triggers.
269 */
276 /* Disallow TRUNCATE triggers on VIEWs */
283 }
285 {
294 /*
295 * We disallow constraint triggers to protect the assumption that
296 * triggers on FKs can't be deferred. See notes with AfterTriggers
297 * data structures, below.
298 */
305 }
306 else
320 {
321 /*
322 * We must take a lock on the target relation to protect against
323 * concurrent drop. It's not clear that AccessShareLock is strong
324 * enough, but we certainly need at least that much... otherwise, we
325 * might end up creating a pg_constraint entry referencing a
326 * nonexistent table.
327 */
329 {
332 }
336 }
338 /* permission checks */
340 {
342 ACL_TRIGGER);
348 {
350 ACL_TRIGGER);
354 }
355 }
357 /*
358 * When called on a partitioned table to create a FOR EACH ROW trigger
359 * that's not internal, we create one trigger for each partition, too.
360 *
361 * For that, we'd better hold lock on all of them ahead of time.
362 */
369 /* Compute tgtype */
376 /* Disallow ROW-level TRUNCATE triggers */
382 /* INSTEAD triggers must be row-level, and can't have WHEN or columns */
384 {
397 }
399 /*
400 * We don't yet support naming ROW transition variables, but the parser
401 * recognizes the syntax so we can give a nicer message here.
402 *
403 * Per standard, REFERENCING TABLE names are only allowed on AFTER
404 * triggers. Per standard, REFERENCING ROW names are not allowed with FOR
405 * EACH STATEMENT. Per standard, each OLD/NEW, ROW/TABLE permutation is
406 * only allowed once. Per standard, OLD may not be specified when
407 * creating a trigger only for INSERT, and NEW may not be specified when
408 * creating a trigger only for DELETE.
409 *
410 * Notice that the standard allows an AFTER ... FOR EACH ROW trigger to
411 * reference both ROW and TABLE transition data.
412 */
414 {
419 {
428 /*
429 * Because of the above test, we omit further ROW-related testing
430 * below. If we later allow naming OLD and NEW ROW variables,
431 * adjustments will be needed below.
432 */
448 /*
449 * We currently don't allow row-level triggers with transition
450 * tables on partition or inheritance children. Such triggers
451 * would somehow need to see tuples converted to the format of the
452 * table they're attached to, and it's not clear which subset of
453 * tuples each child should see. See also the prohibitions in
454 * ATExecAttachPartition() and ATExecAddInherit().
455 */
457 {
458 /* Use appropriate error message. */
463 else
467 }
479 /*
480 * We currently don't allow multi-event triggers ("INSERT OR
481 * UPDATE") with transition tables, because it's not clear how to
482 * handle INSERT ... ON CONFLICT statements which can fire both
483 * INSERT and UPDATE triggers. We show the inserted tuples to
484 * INSERT triggers and the updated tuples to UPDATE triggers, but
485 * it's not yet clear what INSERT OR UPDATE trigger should see.
486 * This restriction could be lifted if we can decide on the right
487 * semantics in a later release.
488 */
496 /*
497 * We currently don't allow column-specific triggers with
498 * transition tables. Per spec, that seems to require
499 * accumulating separate transition tables for each combination of
500 * columns, which is a lot of work for a rather marginal feature.
501 */
507 /*
508 * We disallow constraint triggers with transition tables, to
509 * protect the assumption that such triggers can't be deferred.
510 * See notes with AfterTriggers data structures, below.
511 *
512 * Currently this is enforced by the grammar, so just Assert here.
513 */
517 {
530 }
531 else
532 {
545 }
546 }
553 }
555 /*
556 * Parse the WHEN clause, if any and we weren't passed an already
557 * transformed one.
558 *
559 * Note that as a side effect, we fill whenRtable when parsing. If we got
560 * an already parsed clause, this does not occur, which is what we want --
561 * no point in adding redundant dependencies below.
562 */
564 {
570 /* Set up a pstate to parse with */
574 /*
575 * Set up nsitems for OLD and NEW references.
576 *
577 * 'OLD' must always have varno equal to 1 and 'NEW' equal to 2.
578 */
580 AccessShareLock,
585 AccessShareLock,
590 /* Transform expression. Copy to be sure we don't modify original */
593 EXPR_KIND_TRIGGER_WHEN,
595 /* we have to fix its collations too */
598 /*
599 * Check for disallowed references to OLD/NEW.
600 *
601 * NB: pull_var_clause is okay here only because we don't allow
602 * subselects in WHEN clauses; it would fail to examine the contents
603 * of subselects.
604 */
607 {
611 {
623 /* system columns are okay here */
661 /* can't happen without add_missing_from, so just elog */
664 }
665 }
667 /* we'll need the rtable for recordDependencyOnExpr */
673 }
675 {
679 }
680 else
681 {
684 }
686 /*
687 * Find and validate the trigger function.
688 */
692 {
697 }
705 /*
706 * Scan pg_trigger to see if there is already a trigger of the same name.
707 * Skip this for internally generated triggers, since we'll modify the
708 * name to be unique below.
709 *
710 * NOTE that this is cool only because we have ShareRowExclusiveLock on
711 * the relation, so the trigger set won't be changing underneath us.
712 */
715 {
717 SysScanDesc tgscan;
720 Anum_pg_trigger_tgrelid,
725 Anum_pg_trigger_tgname,
732 /* There should be at most one matching tuple */
734 {
742 /* copy the tuple to use in CatalogTupleUpdate() */
744 }
746 }
749 {
750 /* Generate the OID for the new trigger. */
752 Anum_pg_trigger_oid);
753 }
754 else
755 {
756 /*
757 * If OR REPLACE was specified, we'll replace the old trigger;
758 * otherwise complain about the duplicate name.
759 */
766 /*
767 * An internal trigger or a child trigger (isClone) cannot be replaced
768 * by a user-defined trigger. However, skip this test when
769 * in_partition, because then we're recursing from a partitioned table
770 * and the check was made at the parent level.
771 */
779 /*
780 * It is not allowed to replace with a constraint trigger; gram.y
781 * should have enforced this already.
782 */
785 /*
786 * It is not allowed to replace an existing constraint trigger,
787 * either. (The reason for these restrictions is partly that it seems
788 * difficult to deal with pending trigger events in such cases, and
789 * partly that the command might imply changing the constraint's
790 * properties as well, which doesn't seem nice.)
791 */
797 }
799 /*
800 * If it's a user-entered CREATE CONSTRAINT TRIGGER command, make a
801 * corresponding pg_constraint entry.
802 */
804 {
805 /* Internal callers should have made their own constraints */
809 CONSTRAINT_TRIGGER,
821 NULL,
822 NULL,
823 NULL,
824 NULL,
828 NULL,
833 NULL,
839 }
841 /*
842 * If trigger is internally generated, modify the provided trigger name to
843 * ensure uniqueness by appending the trigger OID. (Callers will usually
844 * supply a simple constant trigger name in these cases.)
845 */
847 {
851 }
852 else
853 {
854 /* user-defined trigger; use the specified trigger name as-is */
856 }
858 /*
859 * Build the new pg_trigger tuple.
860 */
879 {
886 {
891 {
893 len++;
894 }
895 }
899 {
904 {
908 }
910 }
914 }
915 else
916 {
920 }
922 /* build column number array if it's a column-specific trigger */
926 else
927 {
933 {
935 int16 attnum;
938 /* Lookup column name. System columns are not allowed */
946 /* Check for duplicates */
948 {
953 name)));
954 }
957 }
958 }
962 /* set tgqual if trigger has WHEN clause */
965 else
971 else
976 else
979 /*
980 * Insert or replace tuple in pg_trigger.
981 */
983 {
986 }
987 else
988 {
989 HeapTuple newtup;
994 }
1007 /*
1008 * Update relation's pg_class entry; if necessary; and if not, send an SI
1009 * message to make other backends (and this one) rebuild relcache entries.
1010 */
1018 {
1024 }
1025 else
1031 /*
1032 * If we're replacing a trigger, flush all the old dependencies before
1033 * recording new ones.
1034 */
1038 /*
1039 * Record dependencies for trigger. Always place a normal dependency on
1040 * the function.
1041 */
1052 {
1053 /*
1054 * Internally-generated trigger for a constraint, so make it an
1055 * internal dependency of the constraint. We can skip depending on
1056 * the relation(s), as there'll be an indirect dependency via the
1057 * constraint.
1058 */
1063 }
1064 else
1065 {
1066 /*
1067 * User CREATE TRIGGER, so place dependencies. We make trigger be
1068 * auto-dropped if its relation is dropped or if the FK relation is
1069 * dropped. (Auto drop is compatible with our pre-7.3 behavior.)
1070 */
1077 {
1082 }
1083 /* Not possible to have an index dependency in this case */
1086 /*
1087 * If it's a user-specified constraint trigger, make the constraint
1088 * internally dependent on the trigger instead of vice versa.
1089 */
1091 {
1096 }
1098 /*
1099 * If it's a partition trigger, create the partition dependencies.
1100 */
1102 {
1107 }
1108 }
1110 /* If column-specific trigger, add normal dependencies on columns */
1112 {
1118 {
1121 }
1122 }
1124 /*
1125 * If it has a WHEN clause, add dependencies on objects mentioned in the
1126 * expression (eg, functions, as well as any columns used).
1127 */
1130 DEPENDENCY_NORMAL);
1132 /* Post creation hook for new trigger */
1134 isInternal);
1136 /*
1137 * Lastly, create the trigger on child relations, if needed.
1138 */
1140 {
1143 MemoryContext oldcxt,
1144 perChildCxt;
1148 ALLOCSET_SMALL_SIZES);
1150 /*
1151 * We don't currently expect to be called with a valid indexOid. If
1152 * that ever changes then we'll need to write code here to find the
1153 * corresponding child index.
1154 */
1159 /* Iterate to create the trigger on each existing partition */
1161 {
1163 Relation childTbl;
1168 /*
1169 * Initialize our fabricated parse node by copying the original
1170 * one, then resetting fields that we pass separately.
1171 */
1176 /* If there is a WHEN clause, create a modified copy of it */
1194 }
1198 }
1200 /* Keep lock on target rel until end of xact */
1204 }
1206 /*
1207 * TriggerSetParentTrigger
1208 * Set a partition's trigger as child of its parent trigger,
1209 * or remove the linkage if parentTrigId is InvalidOid.
1210 *
1211 * This updates the constraint's pg_trigger row to show it as inherited, and
1212 * adds PARTITION dependencies to prevent the trigger from being deleted
1213 * on its own. Alternatively, reverse that.
1214 */
1215 void
1217 Oid childTrigId,
1218 Oid parentTrigId,
1219 Oid childTableId)
1220 {
1221 SysScanDesc tgscan;
1223 Form_pg_trigger trigForm;
1224 HeapTuple tuple,
1225 newtup;
1226 ObjectAddress depender;
1227 ObjectAddress referenced;
1229 /*
1230 * Find the trigger to delete.
1231 */
1233 Anum_pg_trigger_oid,
1246 {
1247 /* don't allow setting parent for a constraint that already has one */
1250 childTrigId);
1263 }
1264 else
1265 {
1271 TriggerRelationId,
1272 DEPENDENCY_PARTITION_PRI);
1274 RelationRelationId,
1275 DEPENDENCY_PARTITION_SEC);
1276 }
1280 }
1283 /*
1284 * Guts of trigger deletion.
1285 */
1286 void
1288 {
1289 Relation tgrel;
1290 SysScanDesc tgscan;
1292 HeapTuple tup;
1293 Oid relid;
1294 Relation rel;
1298 /*
1299 * Find the trigger to delete.
1300 */
1302 Anum_pg_trigger_oid,
1313 /*
1314 * Open and exclusive-lock the relation the trigger belongs to.
1315 */
1336 /*
1337 * Delete the pg_trigger tuple.
1338 */
1344 /*
1345 * We do not bother to try to determine whether any other triggers remain,
1346 * which would be needed in order to decide whether it's safe to clear the
1347 * relation's relhastriggers. (In any case, there might be a concurrent
1348 * process adding new triggers.) Instead, just force a relcache inval to
1349 * make other backends (and this one too!) rebuild their relcache entries.
1350 * There's no great harm in leaving relhastriggers true even if there are
1351 * no triggers left.
1352 */
1355 /* Keep lock on trigger's rel until end of xact */
1357 }
1359 /*
1360 * get_trigger_oid - Look up a trigger by name to find its OID.
1361 *
1362 * If missing_ok is false, throw an error if trigger not found. If
1363 * true, just return InvalidOid.
1364 */
1365 Oid
1367 {
1368 Relation tgrel;
1370 SysScanDesc tgscan;
1371 HeapTuple tup;
1372 Oid oid;
1374 /*
1375 * Find the trigger, verify permissions, set up object address
1376 */
1380 Anum_pg_trigger_tgrelid,
1384 Anum_pg_trigger_tgname,
1394 {
1401 }
1402 else
1403 {
1405 }
1410 }
1412 /*
1413 * Perform permissions and integrity checks before acquiring a relation lock.
1414 */
1415 static void
1418 {
1419 HeapTuple tuple;
1420 Form_pg_class form;
1427 /* only tables and views can have triggers */
1437 /* you must own the table to rename one of its triggers */
1447 }
1449 /*
1450 * renametrig - changes the name of a trigger on a relation
1451 *
1452 * trigger name is changed in trigger catalog.
1453 * No record of the previous name is kept.
1454 *
1455 * get proper relrelation from relation catalog (if not arg)
1456 * scan trigger catalog
1457 * for name conflict (within rel)
1458 * for original trigger (if not arg)
1459 * modify tgname in trigger tuple
1460 * update row in catalog
1461 */
1462 ObjectAddress
1464 {
1465 Oid tgoid;
1466 Relation targetrel;
1467 Relation tgrel;
1468 HeapTuple tuple;
1469 SysScanDesc tgscan;
1471 Oid relid;
1472 ObjectAddress address;
1474 /*
1475 * Look up name, check permissions, and acquire lock (which we will NOT
1476 * release until end of transaction).
1477 */
1480 RangeVarCallbackForRenameTrigger,
1481 NULL);
1483 /* Have lock already, so just need to build relcache entry. */
1486 /*
1487 * On partitioned tables, this operation recurses to partitions. Lock all
1488 * tables upfront.
1489 */
1495 /*
1496 * Search for the trigger to modify.
1497 */
1499 Anum_pg_trigger_tgrelid,
1503 Anum_pg_trigger_tgname,
1509 {
1510 Form_pg_trigger trigform;
1515 /*
1516 * If the trigger descends from a trigger on a parent partitioned
1517 * table, reject the rename. We don't allow a trigger in a partition
1518 * to differ in name from that of its parent: that would lead to an
1519 * inconsistency that pg_dump would not reproduce.
1520 */
1529 /* Rename the trigger on this relation ... */
1533 /* ... and if it is partitioned, recurse to its partitions */
1535 {
1539 {
1544 }
1545 }
1546 }
1547 else
1548 {
1553 }
1561 /*
1562 * Close rel, but keep exclusive lock!
1563 */
1567 }
1569 /*
1570 * Subroutine for renametrig -- perform the actual work of renaming one
1571 * trigger on one table.
1572 *
1573 * If the trigger has a name different from the expected one, raise a
1574 * NOTICE about it.
1575 */
1576 static void
1579 {
1580 HeapTuple tuple;
1581 Form_pg_trigger tgform;
1583 SysScanDesc tgscan;
1585 /* If the trigger already has the new name, nothing to do. */
1590 /*
1591 * Before actually trying the rename, search for triggers with the same
1592 * name. The update would fail with an ugly message in that case, and it
1593 * is better to throw a nicer error.
1594 */
1596 Anum_pg_trigger_tgrelid,
1600 Anum_pg_trigger_tgname,
1612 /*
1613 * The target name is free; update the existing pg_trigger tuple with it.
1614 */
1618 /*
1619 * If the trigger has a name different from what we expected, let the user
1620 * know. (We can proceed anyway, since we must have reached here following
1621 * a tgparentid link.)
1622 */
1635 /*
1636 * Invalidate relation's relcache entry so that other backends (and this
1637 * one too!) are sent SI message to make them rebuild relcache entries.
1638 * (Ideally this should happen automatically...)
1639 */
1641 }
1643 /*
1644 * Subroutine for renametrig -- Helper for recursing to partitions when
1645 * renaming triggers on a partitioned table.
1646 */
1647 static void
1650 {
1651 SysScanDesc tgscan;
1652 ScanKeyData key;
1653 HeapTuple tuple;
1655 /*
1656 * Given a relation and the OID of a trigger on parent relation, find the
1657 * corresponding trigger in the child and rename that trigger to the given
1658 * name.
1659 */
1661 Anum_pg_trigger_tgrelid,
1667 {
1669 Relation partitionRel;
1676 /* Rename the trigger on this partition */
1679 /* And if this relation is partitioned, recurse to its partitions */
1681 {
1686 {
1691 }
1692 }
1695 /* There should be at most one matching tuple */
1697 }
1699 }
1701 /*
1702 * EnableDisableTrigger()
1703 *
1704 * Called by ALTER TABLE ENABLE/DISABLE [ REPLICA | ALWAYS ] TRIGGER
1705 * to change 'tgenabled' field for the specified trigger(s)
1706 *
1707 * rel: relation to process (caller must hold suitable lock on it)
1708 * tgname: name of trigger to process, or NULL to scan all triggers
1709 * tgparent: if not zero, process only triggers with this tgparentid
1710 * fires_when: new value for tgenabled field. In addition to generic
1711 * enablement/disablement, this also defines when the trigger
1712 * should be fired in session replication roles.
1713 * skip_system: if true, skip "system" triggers (constraint triggers)
1714 * recurse: if true, recurse to partitions
1715 *
1716 * Caller should have checked permissions for the table; here we also
1717 * enforce that superuser privilege is required to alter the state of
1718 * system triggers
1719 */
1720 void
1723 LOCKMODE lockmode)
1724 {
1725 Relation tgrel;
1728 SysScanDesc tgscan;
1729 HeapTuple tuple;
1733 /* Scan the relevant entries in pg_triggers */
1737 Anum_pg_trigger_tgrelid,
1741 {
1743 Anum_pg_trigger_tgname,
1747 }
1748 else
1757 {
1764 {
1765 /* system trigger ... ok to process? */
1773 }
1778 {
1779 /* need to change this one ... make a copy to scribble on */
1790 }
1792 /*
1793 * When altering FOR EACH ROW triggers on a partitioned table, do the
1794 * same on the partitions as well, unless ONLY is specified.
1795 *
1796 * Note that we recurse even if we didn't change the trigger above,
1797 * because the partitions' copy of the trigger may have a different
1798 * value of tgenabled than the parent's trigger and thus might need to
1799 * be changed.
1800 */
1804 {
1809 {
1810 Relation part;
1813 /* Match on child triggers' tgparentid, not their name */
1816 lockmode);
1818 }
1819 }
1823 }
1835 /*
1836 * If we changed anything, broadcast a SI inval message to force each
1837 * backend (including our own!) to rebuild relation's relcache entry.
1838 * Otherwise they will fail to apply the change promptly.
1839 */
1842 }
1845 /*
1846 * Build trigger data to attach to the given relcache entry.
1847 *
1848 * Note that trigger data attached to a relcache entry must be stored in
1849 * CacheMemoryContext to ensure it survives as long as the relcache entry.
1850 * But we should be running in a less long-lived working context. To avoid
1851 * leaking cache memory if this routine fails partway through, we build a
1852 * temporary TriggerDesc in working memory and then copy the completed
1853 * structure into cache memory.
1854 */
1855 void
1857 {
1862 Relation tgrel;
1863 ScanKeyData skey;
1864 SysScanDesc tgscan;
1865 HeapTuple htup;
1866 MemoryContext oldContext;
1869 /*
1870 * Allocate a working array to hold the triggers (the array is extended if
1871 * necessary)
1872 */
1877 /*
1878 * Note: since we scan the triggers using TriggerRelidNameIndexId, we will
1879 * be reading the triggers in name order, except possibly during
1880 * emergency-recovery operations (ie, IgnoreSystemIndexes). This in turn
1881 * ensures that triggers will be fired in name order.
1882 */
1884 Anum_pg_trigger_tgrelid,
1893 {
1896 Datum datum;
1900 {
1903 }
1920 /* tgattr is first var-width field, so OK to access directly */
1923 {
1927 }
1928 else
1931 {
1936 Anum_pg_trigger_tgargs,
1944 {
1947 }
1948 }
1949 else
1957 else
1965 else
1972 else
1975 numtrigs++;
1976 }
1981 /* There might not be any triggers */
1983 {
1986 }
1988 /* Build trigdesc */
1995 /* Copy completed trigdesc into cache storage */
2000 /* Release working memory */
2002 }
2004 /*
2005 * Update the TriggerDesc's hint flags to include the specified trigger
2006 */
2007 static void
2009 {
2057 /* there are no row-level truncate triggers */
2077 }
2079 /*
2080 * Copy a TriggerDesc data structure.
2081 *
2082 * The copy is allocated in the current memory context.
2083 */
2084 TriggerDesc *
2086 {
2103 {
2106 {
2113 }
2115 {
2117 int16 j;
2123 }
2130 trigger++;
2131 }
2134 }
2136 /*
2137 * Free a TriggerDesc data structure.
2138 */
2139 void
2141 {
2150 {
2155 {
2159 }
2166 trigger++;
2167 }
2170 }
2172 /*
2173 * Compare two TriggerDesc structures for logical equality.
2174 */
2175 #ifdef NOT_USED
2176 bool
2178 {
2180 j;
2182 /*
2183 * We need not examine the hint flags, just the trigger array itself; if
2184 * we have the same triggers with the same types, the flags should match.
2185 *
2186 * As of 7.3 we assume trigger set ordering is significant in the
2187 * comparison; so we just compare corresponding slots of the two sets.
2188 *
2189 * Note: comparing the stringToNode forms of the WHEN clauses means that
2190 * parse column locations will affect the result. This is okay as long as
2191 * this function is only used for detecting exact equality, as for example
2192 * in checking for staleness of a cache entry.
2193 */
2195 {
2201 {
2258 }
2259 }
2263 }
2266 /*
2267 * Check if there is a row-level trigger with transition tables that prevents
2268 * a table from becoming an inheritance child or partition. Return the name
2269 * of the first such incompatible trigger, or NULL if there is none.
2270 */
2273 {
2275 {
2279 {
2284 }
2285 }
2288 }
2290 /*
2291 * Call a trigger function.
2292 *
2293 * trigdata: trigger descriptor.
2294 * tgindx: trigger's index in finfo and instr arrays.
2295 * finfo: array of cached trigger function call information.
2296 * instr: optional array of EXPLAIN ANALYZE instrumentation state.
2297 * per_tuple_context: memory context to execute the function in.
2298 *
2299 * Returns the tuple (or NULL) as returned by the function.
2300 */
2301 static HeapTuple
2306 MemoryContext per_tuple_context)
2307 {
2309 PgStat_FunctionCallUsage fcusage;
2310 Datum result;
2311 MemoryContext oldContext;
2313 /*
2314 * Protect against code paths that may fail to initialize transition table
2315 * info.
2316 */
2327 /*
2328 * We cache fmgr lookup info, to avoid making the lookup again on each
2329 * call.
2330 */
2336 /*
2337 * If doing EXPLAIN ANALYZE, start charging time to this trigger.
2338 */
2342 /*
2343 * Do the function evaluation in the per-tuple memory context, so that
2344 * leaked memory will be reclaimed once per tuple. Note in particular that
2345 * any new tuple created by the trigger function will live till the end of
2346 * the tuple cycle.
2347 */
2350 /*
2351 * Call the function, passing no arguments but setting a context.
2352 */
2358 MyTriggerDepth++;
2360 {
2362 }
2364 {
2365 MyTriggerDepth--;
2366 }
2373 /*
2374 * Trigger protocol allows function to return a null pointer, but NOT to
2375 * set the isnull result flag.
2376 */
2383 /*
2384 * If doing EXPLAIN ANALYZE, stop charging time to this trigger, and count
2385 * one "tuple returned" (really the number of firings).
2386 */
2391 }
2393 void
2395 {
2407 /* no-op if we already fired BS triggers in this context */
2409 CMD_INSERT))
2414 TRIGGER_EVENT_BEFORE;
2417 {
2419 HeapTuple newtuple;
2422 TRIGGER_TYPE_STATEMENT,
2423 TRIGGER_TYPE_BEFORE,
2424 TRIGGER_TYPE_INSERT))
2432 i,
2441 }
2442 }
2444 void
2447 {
2452 TRIGGER_EVENT_INSERT,
2455 }
2457 bool
2460 {
2469 TRIGGER_EVENT_ROW |
2470 TRIGGER_EVENT_BEFORE;
2473 {
2475 HeapTuple oldtuple;
2478 TRIGGER_TYPE_ROW,
2479 TRIGGER_TYPE_BEFORE,
2480 TRIGGER_TYPE_INSERT))
2493 i,
2498 {
2502 }
2504 {
2507 /*
2508 * After a tuple in a partition goes through a trigger, the user
2509 * could have changed the partition key enough that the tuple no
2510 * longer fits the partition. Verify that.
2511 */
2516 errmsg("moving row to another partition during a BEFORE FOR EACH ROW trigger is not supported"),
2525 /* signal tuple should be re-fetched if used */
2527 }
2528 }
2531 }
2533 void
2537 {
2543 TRIGGER_EVENT_INSERT,
2546 transition_capture,
2548 }
2550 bool
2553 {
2562 TRIGGER_EVENT_ROW |
2563 TRIGGER_EVENT_INSTEAD;
2566 {
2568 HeapTuple oldtuple;
2571 TRIGGER_TYPE_ROW,
2572 TRIGGER_TYPE_INSTEAD,
2573 TRIGGER_TYPE_INSERT))
2586 i,
2591 {
2595 }
2597 {
2603 /* signal tuple should be re-fetched if used */
2605 }
2606 }
2609 }
2611 void
2613 {
2625 /* no-op if we already fired BS triggers in this context */
2627 CMD_DELETE))
2632 TRIGGER_EVENT_BEFORE;
2635 {
2637 HeapTuple newtuple;
2640 TRIGGER_TYPE_STATEMENT,
2641 TRIGGER_TYPE_BEFORE,
2642 TRIGGER_TYPE_DELETE))
2650 i,
2659 }
2660 }
2662 void
2665 {
2670 TRIGGER_EVENT_DELETE,
2673 }
2675 /*
2676 * Execute BEFORE ROW DELETE triggers.
2677 *
2678 * True indicates caller can proceed with the delete. False indicates caller
2679 * need to suppress the delete and additionally if requested, we need to pass
2680 * back the concurrently updated tuple if any.
2681 */
2682 bool
2685 ItemPointer tupleid,
2686 HeapTuple fdw_trigtuple,
2690 {
2695 HeapTuple trigtuple;
2701 {
2709 /*
2710 * If the tuple was concurrently updated and the caller of this
2711 * function requested for the updated tuple, skip the trigger
2712 * execution.
2713 */
2715 {
2718 }
2721 }
2722 else
2723 {
2726 }
2730 TRIGGER_EVENT_ROW |
2731 TRIGGER_EVENT_BEFORE;
2734 {
2735 HeapTuple newtuple;
2739 TRIGGER_TYPE_ROW,
2740 TRIGGER_TYPE_BEFORE,
2741 TRIGGER_TYPE_DELETE))
2751 i,
2756 {
2759 }
2762 }
2767 }
2769 /*
2770 * Note: is_crosspart_update must be true if the DELETE is being performed
2771 * as part of a cross-partition update.
2772 */
2773 void
2776 ItemPointer tupleid,
2777 HeapTuple fdw_trigtuple,
2780 {
2785 {
2791 NULL,
2792 relinfo,
2793 tupleid,
2794 LockTupleExclusive,
2795 slot,
2796 NULL,
2797 NULL,
2798 NULL);
2799 else
2803 TRIGGER_EVENT_DELETE,
2805 transition_capture,
2806 is_crosspart_update);
2807 }
2808 }
2810 bool
2812 HeapTuple trigtuple)
2813 {
2821 TRIGGER_EVENT_ROW |
2822 TRIGGER_EVENT_INSTEAD;
2828 {
2829 HeapTuple rettuple;
2833 TRIGGER_TYPE_ROW,
2834 TRIGGER_TYPE_INSTEAD,
2835 TRIGGER_TYPE_DELETE))
2845 i,
2853 }
2855 }
2857 void
2859 {
2872 /* no-op if we already fired BS triggers in this context */
2874 CMD_UPDATE))
2877 /* statement-level triggers operate on the parent table */
2884 TRIGGER_EVENT_BEFORE;
2888 {
2890 HeapTuple newtuple;
2893 TRIGGER_TYPE_STATEMENT,
2894 TRIGGER_TYPE_BEFORE,
2895 TRIGGER_TYPE_UPDATE))
2903 i,
2912 }
2913 }
2915 void
2918 {
2921 /* statement-level triggers operate on the parent table */
2926 TRIGGER_EVENT_UPDATE,
2929 transition_capture,
2931 }
2933 bool
2936 ItemPointer tupleid,
2937 HeapTuple fdw_trigtuple,
2941 {
2945 HeapTuple trigtuple;
2951 LockTupleMode lockmode;
2953 /* Determine lock mode to use */
2958 {
2961 /* get a copy of the on-disk tuple we are planning to update */
2967 /*
2968 * In READ COMMITTED isolation level it's possible that target tuple
2969 * was changed due to concurrent update. In that case we have a raw
2970 * subplan output tuple in epqslot_candidate, and need to form a new
2971 * insertable tuple using ExecGetUpdateNewTuple to replace the one we
2972 * received in newslot. Neither we nor our callers have any further
2973 * interest in the passed-in tuple, so it's okay to overwrite newslot
2974 * with the newer data.
2975 */
2977 {
2981 oldslot);
2983 /*
2984 * Typically, the caller's newslot was also generated by
2985 * ExecGetUpdateNewTuple, so that epqslot_clean will be the same
2986 * slot and copying is not needed. But do the right thing if it
2987 * isn't.
2988 */
2992 /*
2993 * At this point newslot contains a virtual tuple that may
2994 * reference some fields of oldslot's tuple in some disk buffer.
2995 * If that tuple is in a different page than the original target
2996 * tuple, then our only pin on that buffer is oldslot's, and we're
2997 * about to release it. Hence we'd better materialize newslot to
2998 * ensure it doesn't contain references into an unpinned buffer.
2999 * (We'd materialize it below anyway, but too late for safety.)
3000 */
3002 }
3004 /*
3005 * Here we convert oldslot to a materialized slot holding trigtuple.
3006 * Neither slot passed to the triggers will hold any buffer pin.
3007 */
3009 }
3010 else
3011 {
3012 /* Put the FDW-supplied tuple into oldslot to unify the cases */
3015 }
3019 TRIGGER_EVENT_ROW |
3020 TRIGGER_EVENT_BEFORE;
3025 {
3027 HeapTuple oldtuple;
3030 TRIGGER_TYPE_ROW,
3031 TRIGGER_TYPE_BEFORE,
3032 TRIGGER_TYPE_UPDATE))
3047 i,
3053 {
3059 }
3061 {
3064 /*
3065 * If the tuple returned by the trigger / being stored, is the old
3066 * row version, and the heap tuple passed to the trigger was
3067 * allocated locally, materialize the slot. Otherwise we might
3068 * free it while still referenced by the slot.
3069 */
3076 /* signal tuple should be re-fetched if used */
3078 }
3079 }
3084 }
3086 /*
3087 * Note: 'src_partinfo' and 'dst_partinfo', when non-NULL, refer to the source
3088 * and destination partitions, respectively, of a cross-partition update of
3089 * the root partitioned table mentioned in the query, given by 'relinfo'.
3090 * 'tupleid' in that case refers to the ctid of the "old" tuple in the source
3091 * partition, and 'newslot' contains the "new" tuple in the destination
3092 * partition. This interface allows to support the requirements of
3093 * ExecCrossPartitionUpdateForeignKey(); is_crosspart_update must be true in
3094 * that case.
3095 */
3096 void
3100 ItemPointer tupleid,
3101 HeapTuple fdw_trigtuple,
3106 {
3113 {
3114 /*
3115 * Note: if the UPDATE is converted into a DELETE+INSERT as part of
3116 * update-partition-key operation, then this function is also called
3117 * separately for DELETE and INSERT to capture transition table rows.
3118 * In such case, either old tuple or new tuple can be NULL.
3119 */
3131 NULL,
3132 tupsrc,
3133 tupleid,
3134 LockTupleExclusive,
3135 oldslot,
3136 NULL,
3137 NULL,
3138 NULL);
3141 else
3146 TRIGGER_EVENT_UPDATE,
3150 transition_capture,
3151 is_crosspart_update);
3152 }
3153 }
3155 bool
3158 {
3168 TRIGGER_EVENT_ROW |
3169 TRIGGER_EVENT_INSTEAD;
3175 {
3177 HeapTuple oldtuple;
3180 TRIGGER_TYPE_ROW,
3181 TRIGGER_TYPE_INSTEAD,
3182 TRIGGER_TYPE_UPDATE))
3198 i,
3203 {
3205 }
3207 {
3213 /* signal tuple should be re-fetched if used */
3215 }
3216 }
3219 }
3221 void
3223 {
3237 TRIGGER_EVENT_BEFORE;
3241 {
3243 HeapTuple newtuple;
3246 TRIGGER_TYPE_STATEMENT,
3247 TRIGGER_TYPE_BEFORE,
3248 TRIGGER_TYPE_TRUNCATE))
3256 i,
3265 }
3266 }
3268 void
3270 {
3276 TRIGGER_EVENT_TRUNCATE,
3279 }
3282 /*
3283 * Fetch tuple into "oldslot", dealing with locking and EPQ if necessary
3284 */
3285 static bool
3289 ItemPointer tid,
3290 LockTupleMode lockmode,
3295 {
3299 {
3300 TM_Result test;
3301 TM_FailureData tmfd;
3306 /* caller must pass an epqstate if EvalPlanQual is possible */
3309 /*
3310 * lock tuple for update
3311 */
3317 lockflags,
3320 /* Let the caller know about the status of this operation */
3327 {
3330 /*
3331 * The target tuple was already updated or deleted by the
3332 * current command, or by a later command in the current
3333 * transaction. We ignore the tuple in the former case, and
3334 * throw error in the latter case, for the same reasons
3335 * enumerated in ExecUpdate and ExecDelete in
3336 * nodeModifyTable.c.
3337 */
3341 errmsg("tuple to be updated was already modified by an operation triggered by the current command"),
3342 errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
3344 /* treat it as deleted; do not process */
3349 {
3350 /*
3351 * Recheck the tuple using EPQ. For MERGE, we leave this
3352 * to the caller (it must do additional rechecking, and
3353 * might end up executing a different action entirely).
3354 */
3356 {
3360 }
3363 relation,
3365 oldslot);
3367 /*
3368 * If PlanQual failed for updated tuple - we must not
3369 * process this tuple!
3370 */
3372 {
3375 }
3376 }
3392 /* tuple was deleted */
3402 }
3403 }
3404 else
3405 {
3406 /*
3407 * We expect the tuple to be present, thus very simple error handling
3408 * suffices.
3409 */
3411 oldslot))
3413 }
3416 }
3418 /*
3419 * Is trigger enabled to fire?
3420 */
3421 static bool
3426 {
3427 /* Check replication-role-dependent enable state */
3429 {
3433 }
3435 {
3439 }
3441 /*
3442 * Check for column-specific trigger (only possible for UPDATE, and in
3443 * fact we *must* ignore tgattr for other event types)
3444 */
3446 {
3452 {
3454 modifiedCols))
3455 {
3458 }
3459 }
3462 }
3464 /* Check for WHEN clause */
3466 {
3469 MemoryContext oldContext;
3474 /*
3475 * trigger is an element of relinfo->ri_TrigDesc->triggers[]; find the
3476 * matching element of relinfo->ri_TrigWhenExprs[]
3477 */
3481 /*
3482 * If first time through for this WHEN expression, build expression
3483 * nodetrees for it. Keep them in the per-query memory context so
3484 * they'll survive throughout the query.
3485 */
3487 {
3492 /* Change references to OLD and NEW to INNER_VAR and OUTER_VAR */
3495 /* ExecPrepareQual wants implicit-AND form */
3499 }
3501 /*
3502 * We will use the EState's per-tuple context for evaluating WHEN
3503 * expressions (creating it if it's not already there).
3504 */
3507 /*
3508 * Finally evaluate the expression, making the old and/or new tuples
3509 * available as INNER_VAR/OUTER_VAR respectively.
3510 */
3515 }
3518 }
3521 /* ----------
3522 * After-trigger stuff
3523 *
3524 * The AfterTriggersData struct holds data about pending AFTER trigger events
3525 * during the current transaction tree. (BEFORE triggers are fired
3526 * immediately so we don't need any persistent state about them.) The struct
3527 * and most of its subsidiary data are kept in TopTransactionContext; however
3528 * some data that can be discarded sooner appears in the CurTransactionContext
3529 * of the relevant subtransaction. Also, the individual event records are
3530 * kept in a separate sub-context of TopTransactionContext. This is done
3531 * mainly so that it's easy to tell from a memory context dump how much space
3532 * is being eaten by trigger events.
3533 *
3534 * Because the list of pending events can grow large, we go to some
3535 * considerable effort to minimize per-event memory consumption. The event
3536 * records are grouped into chunks and common data for similar events in the
3537 * same chunk is only stored once.
3538 *
3539 * XXX We need to be able to save the per-event data in a file if it grows too
3540 * large.
3541 * ----------
3542 */
3544 /* Per-trigger SET CONSTRAINT status */
3546 {
3547 Oid sct_tgoid;
3553 /*
3554 * SET CONSTRAINT intra-transaction status.
3555 *
3556 * We make this a single palloc'd object so it can be copied and freed easily.
3557 *
3558 * all_isset and all_isdeferred are used to keep track
3559 * of SET CONSTRAINTS ALL {DEFERRED, IMMEDIATE}.
3560 *
3561 * trigstates[] stores per-trigger tgisdeferred settings.
3562 */
3564 {
3575 /*
3576 * Per-trigger-event data
3577 *
3578 * The actual per-event data, AfterTriggerEventData, includes DONE/IN_PROGRESS
3579 * status bits, up to two tuple CTIDs, and optionally two OIDs of partitions.
3580 * Each event record also has an associated AfterTriggerSharedData that is
3581 * shared across all instances of similar events within a "chunk".
3582 *
3583 * For row-level triggers, we arrange not to waste storage on unneeded ctid
3584 * fields. Updates of regular tables use two; inserts and deletes of regular
3585 * tables use one; foreign tables always use zero and save the tuple(s) to a
3586 * tuplestore. AFTER_TRIGGER_FDW_FETCH directs AfterTriggerExecute() to
3587 * retrieve a fresh tuple or pair of tuples from that tuplestore, while
3588 * AFTER_TRIGGER_FDW_REUSE directs it to use the most-recently-retrieved
3589 * tuple(s). This permits storing tuples once regardless of the number of
3590 * row-level triggers on a foreign table.
3591 *
3592 * When updates on partitioned tables cause rows to move between partitions,
3593 * the OIDs of both partitions are stored too, so that the tuples can be
3594 * fetched; such entries are marked AFTER_TRIGGER_CP_UPDATE (for "cross-
3595 * partition update").
3596 *
3597 * Note that we need triggers on foreign tables to be fired in exactly the
3598 * order they were queued, so that the tuples come out of the tuplestore in
3599 * the right order. To ensure that, we forbid deferrable (constraint)
3600 * triggers on foreign tables. This also ensures that such triggers do not
3601 * get deferred into outer trigger query levels, meaning that it's okay to
3602 * destroy the tuplestore at the end of the query level.
3603 *
3604 * Statement-level triggers always bear AFTER_TRIGGER_1CTID, though they
3605 * require no ctid field. We lack the flag bit space to neatly represent that
3606 * distinct case, and it seems unlikely to be worth much trouble.
3607 *
3608 * Note: ats_firing_id is initially zero and is set to something else when
3609 * AFTER_TRIGGER_IN_PROGRESS is set. It indicates which trigger firing
3610 * cycle the trigger will be fired in (or was fired in, if DONE is set).
3611 * Although this is mutable state, we can keep it in AfterTriggerSharedData
3612 * because all instances of the same type of event in a given event list will
3613 * be fired at the same time, if they were queued between the same firing
3614 * cycles. So we need only ensure that ats_firing_id is zero when attaching
3615 * a new event to an existing AfterTriggerSharedData record.
3616 */
3620 #define AFTER_TRIGGER_DONE 0x80000000
3621 #define AFTER_TRIGGER_IN_PROGRESS 0x40000000
3622 /* bits describing the size and tuple sources of this event */
3623 #define AFTER_TRIGGER_FDW_REUSE 0x00000000
3624 #define AFTER_TRIGGER_FDW_FETCH 0x20000000
3625 #define AFTER_TRIGGER_1CTID 0x10000000
3626 #define AFTER_TRIGGER_2CTID 0x30000000
3627 #define AFTER_TRIGGER_CP_UPDATE 0x08000000
3628 #define AFTER_TRIGGER_TUP_BITS 0x38000000
3632 {
3644 {
3649 /*
3650 * During a cross-partition update of a partitioned table, we also store
3651 * the OIDs of source and destination partitions that are needed to fetch
3652 * the old (ctid1) and the new tuple (ctid2) from, respectively.
3653 */
3654 Oid ate_src_part;
3655 Oid ate_dst_part;
3658 /* AfterTriggerEventData, minus ate_src_part, ate_dst_part */
3660 {
3661 TriggerFlags ate_flags;
3662 ItemPointerData ate_ctid1;
3663 ItemPointerData ate_ctid2;
3666 /* AfterTriggerEventData, minus ate_*_part and ate_ctid2 */
3668 {
3673 /* AfterTriggerEventData, minus ate_*_part, ate_ctid1 and ate_ctid2 */
3675 {
3679 #define SizeofTriggerEvent(evt) \
3680 (((evt)->ate_flags & AFTER_TRIGGER_TUP_BITS) == AFTER_TRIGGER_CP_UPDATE ? \
3681 sizeof(AfterTriggerEventData) : \
3682 (((evt)->ate_flags & AFTER_TRIGGER_TUP_BITS) == AFTER_TRIGGER_2CTID ? \
3683 sizeof(AfterTriggerEventDataNoOids) : \
3684 (((evt)->ate_flags & AFTER_TRIGGER_TUP_BITS) == AFTER_TRIGGER_1CTID ? \
3685 sizeof(AfterTriggerEventDataOneCtid) : \
3686 sizeof(AfterTriggerEventDataZeroCtids))))
3688 #define GetTriggerSharedData(evt) \
3689 ((AfterTriggerShared) ((char *) (evt) + ((evt)->ate_flags & AFTER_TRIGGER_OFFSET)))
3691 /*
3692 * To avoid palloc overhead, we keep trigger events in arrays in successively-
3693 * larger chunks (a slightly more sophisticated version of an expansible
3694 * array). The space between CHUNK_DATA_START and freeptr is occupied by
3695 * AfterTriggerEventData records; the space between endfree and endptr is
3696 * occupied by AfterTriggerSharedData records.
3697 */
3699 {
3704 /* event data follows here */
3707 #define CHUNK_DATA_START(cptr) ((char *) (cptr) + MAXALIGN(sizeof(AfterTriggerEventChunk)))
3709 /* A list of events */
3711 {
3717 /* Macros to help in iterating over a list of events */
3718 #define for_each_chunk(cptr, evtlist) \
3719 for (cptr = (evtlist).head; cptr != NULL; cptr = cptr->next)
3720 #define for_each_event(eptr, cptr) \
3721 for (eptr = (AfterTriggerEvent) CHUNK_DATA_START(cptr); \
3722 (char *) eptr < (cptr)->freeptr; \
3723 eptr = (AfterTriggerEvent) (((char *) eptr) + SizeofTriggerEvent(eptr)))
3724 /* Use this if no special per-chunk processing is needed */
3725 #define for_each_event_chunk(eptr, cptr, evtlist) \
3726 for_each_chunk(cptr, evtlist) for_each_event(eptr, cptr)
3728 /* Macros for iterating from a start point that might not be list start */
3729 #define for_each_chunk_from(cptr) \
3730 for (; cptr != NULL; cptr = cptr->next)
3731 #define for_each_event_from(eptr, cptr) \
3732 for (; \
3733 (char *) eptr < (cptr)->freeptr; \
3734 eptr = (AfterTriggerEvent) (((char *) eptr) + SizeofTriggerEvent(eptr)))
3737 /*
3738 * All per-transaction data for the AFTER TRIGGERS module.
3739 *
3740 * AfterTriggersData has the following fields:
3741 *
3742 * firing_counter is incremented for each call of afterTriggerInvokeEvents.
3743 * We mark firable events with the current firing cycle's ID so that we can
3744 * tell which ones to work on. This ensures sane behavior if a trigger
3745 * function chooses to do SET CONSTRAINTS: the inner SET CONSTRAINTS will
3746 * only fire those events that weren't already scheduled for firing.
3747 *
3748 * state keeps track of the transaction-local effects of SET CONSTRAINTS.
3749 * This is saved and restored across failed subtransactions.
3750 *
3751 * events is the current list of deferred events. This is global across
3752 * all subtransactions of the current transaction. In a subtransaction
3753 * abort, we know that the events added by the subtransaction are at the
3754 * end of the list, so it is relatively easy to discard them. The event
3755 * list chunks themselves are stored in event_cxt.
3756 *
3757 * query_depth is the current depth of nested AfterTriggerBeginQuery calls
3758 * (-1 when the stack is empty).
3759 *
3760 * query_stack[query_depth] is the per-query-level data, including these fields:
3761 *
3762 * events is a list of AFTER trigger events queued by the current query.
3763 * None of these are valid until the matching AfterTriggerEndQuery call
3764 * occurs. At that point we fire immediate-mode triggers, and append any
3765 * deferred events to the main events list.
3766 *
3767 * fdw_tuplestore is a tuplestore containing the foreign-table tuples
3768 * needed by events queued by the current query. (Note: we use just one
3769 * tuplestore even though more than one foreign table might be involved.
3770 * This is okay because tuplestores don't really care what's in the tuples
3771 * they store; but it's possible that someday it'd break.)
3772 *
3773 * tables is a List of AfterTriggersTableData structs for target tables
3774 * of the current query (see below).
3775 *
3776 * maxquerydepth is just the allocated length of query_stack.
3777 *
3778 * trans_stack holds per-subtransaction data, including these fields:
3779 *
3780 * state is NULL or a pointer to a saved copy of the SET CONSTRAINTS
3781 * state data. Each subtransaction level that modifies that state first
3782 * saves a copy, which we use to restore the state if we abort.
3783 *
3784 * events is a copy of the events head/tail pointers,
3785 * which we use to restore those values during subtransaction abort.
3786 *
3787 * query_depth is the subtransaction-start-time value of query_depth,
3788 * which we similarly use to clean up at subtransaction abort.
3789 *
3790 * firing_counter is the subtransaction-start-time value of firing_counter.
3791 * We use this to recognize which deferred triggers were fired (or marked
3792 * for firing) within an aborted subtransaction.
3793 *
3794 * We use GetCurrentTransactionNestLevel() to determine the correct array
3795 * index in trans_stack. maxtransdepth is the number of allocated entries in
3796 * trans_stack. (By not keeping our own stack pointer, we can avoid trouble
3797 * in cases where errors during subxact abort cause multiple invocations
3798 * of AfterTriggerEndSubXact() at the same nesting depth.)
3799 *
3800 * We create an AfterTriggersTableData struct for each target table of the
3801 * current query, and each operation mode (INSERT/UPDATE/DELETE), that has
3802 * either transition tables or statement-level triggers. This is used to
3803 * hold the relevant transition tables, as well as info tracking whether
3804 * we already queued the statement triggers. (We use that info to prevent
3805 * firing the same statement triggers more than once per statement, or really
3806 * once per transition table set.) These structs, along with the transition
3807 * table tuplestores, live in the (sub)transaction's CurTransactionContext.
3808 * That's sufficient lifespan because we don't allow transition tables to be
3809 * used by deferrable triggers, so they only need to survive until
3810 * AfterTriggerEndQuery.
3811 */
3817 {
3823 /* per-query-level data: */
3828 /* per-subtransaction-level data: */
3833 struct AfterTriggersQueryData
3834 {
3838 };
3840 struct AfterTriggersTransData
3841 {
3842 /* these fields are just for resetting at subtrans abort: */
3847 };
3849 struct AfterTriggersTableData
3850 {
3851 /* relid + cmdType form the lookup key for these structs: */
3859 /*
3860 * We maintain separate transition tables for UPDATE/INSERT/DELETE since
3861 * MERGE can run all three actions in a single statement. Note that UPDATE
3862 * needs both old and new transition tables whereas INSERT needs only new,
3863 * and DELETE needs only old.
3864 */
3866 /* "old" transition table for UPDATE, if any */
3868 /* "new" transition table for UPDATE, if any */
3870 /* "old" transition table for DELETE, if any */
3872 /* "new" transition table for INSERT, if any */
3876 };
3881 AfterTriggerEvent event,
3888 MemoryContext per_tuple_context,
3892 CmdType cmdType);
3894 TupleDesc tupdesc);
3913 /*
3914 * Get the FDW tuplestore for the current trigger query level, creating it
3915 * if necessary.
3916 */
3919 {
3924 {
3925 MemoryContext oldcxt;
3926 ResourceOwner saveResourceOwner;
3928 /*
3929 * Make the tuplestore valid until end of subtransaction. We really
3930 * only need it until AfterTriggerEndQuery().
3931 */
3942 }
3945 }
3947 /* ----------
3948 * afterTriggerCheckState()
3949 *
3950 * Returns true if the trigger event is actually in state DEFERRED.
3951 * ----------
3952 */
3953 static bool
3955 {
3960 /*
3961 * For not-deferrable triggers (i.e. normal AFTER ROW triggers and
3962 * constraints declared NOT DEFERRABLE), the state is always false.
3963 */
3967 /*
3968 * If constraint state exists, SET CONSTRAINTS might have been executed
3969 * either for this trigger or for all triggers.
3970 */
3972 {
3973 /* Check for SET CONSTRAINTS for this specific trigger. */
3975 {
3978 }
3980 /* Check for SET CONSTRAINTS ALL. */
3983 }
3985 /*
3986 * Otherwise return the default state for the trigger.
3987 */
3989 }
3991 /* ----------
3992 * afterTriggerCopyBitmap()
3993 *
3994 * Copy bitmap into AfterTriggerEvents memory context, which is where the after
3995 * trigger events are kept.
3996 * ----------
3997 */
4000 {
4002 MemoryContext oldcxt;
4007 /* Create event context if we didn't already */
4012 ALLOCSET_DEFAULT_SIZES);
4021 }
4023 /* ----------
4024 * afterTriggerAddEvent()
4025 *
4026 * Add a new trigger event to the specified queue.
4027 * The passed-in event data is copied.
4028 * ----------
4029 */
4030 static void
4033 {
4037 AfterTriggerShared newshared;
4038 AfterTriggerEvent newevent;
4040 /*
4041 * If empty list or not enough room in the tail chunk, make a new chunk.
4042 * We assume here that a new shared record will always be needed.
4043 */
4047 {
4048 Size chunksize;
4050 /* Create event context if we didn't already */
4055 ALLOCSET_DEFAULT_SIZES);
4057 /*
4058 * Chunk size starts at 1KB and is allowed to increase up to 1MB.
4059 * These numbers are fairly arbitrary, though there is a hard limit at
4060 * AFTER_TRIGGER_OFFSET; else we couldn't link event records to their
4061 * shared records using the available space in ate_flags. Another
4062 * constraint is that if the chunk size gets too huge, the search loop
4063 * below would get slow given a (not too common) usage pattern with
4064 * many distinct event types in a chunk. Therefore, we double the
4065 * preceding chunk size only if there weren't too many shared records
4066 * in the preceding chunk; otherwise we halve it. This gives us some
4067 * ability to adapt to the actual usage pattern of the current query
4068 * while still having large chunk sizes in typical usage. All chunk
4069 * sizes used should be MAXALIGN multiples, to ensure that the shared
4070 * records will be aligned safely.
4071 */
4072 #define MIN_CHUNK_SIZE 1024
4073 #define MAX_CHUNK_SIZE (1024*1024)
4075 #if MAX_CHUNK_SIZE > (AFTER_TRIGGER_OFFSET+1)
4076 #error MAX_CHUNK_SIZE must not exceed AFTER_TRIGGER_OFFSET
4077 #endif
4081 else
4082 {
4083 /* preceding chunk size... */
4085 /* check number of shared records in preceding chunk */
4089 else
4092 }
4101 else
4104 /* events->tailfree is now out of sync, but we'll fix it below */
4105 }
4107 /*
4108 * Try to locate a matching shared-data record already in the chunk. If
4109 * none, make a new one.
4110 */
4113 newshared--)
4114 {
4121 }
4123 {
4127 }
4129 /* Insert the data */
4132 /* ... and link the new event to its shared record */
4138 }
4140 /* ----------
4141 * afterTriggerFreeEventList()
4142 *
4143 * Free all the event storage in the given list.
4144 * ----------
4145 */
4146 static void
4148 {
4152 {
4155 }
4158 }
4160 /* ----------
4161 * afterTriggerRestoreEventList()
4162 *
4163 * Restore an event list to its prior length, removing all the events
4164 * added since it had the value old_events.
4165 * ----------
4166 */
4167 static void
4170 {
4175 {
4176 /* restoring to a completely empty state, so free everything */
4178 }
4179 else
4180 {
4182 /* free any chunks after the last one we want to keep */
4184 {
4187 }
4188 /* and clean up the tail chunk to be the right length */
4192 /*
4193 * We don't make any effort to remove now-unused shared data records.
4194 * They might still be useful, anyway.
4195 */
4196 }
4197 }
4199 /* ----------
4200 * afterTriggerDeleteHeadEventChunk()
4201 *
4202 * Remove the first chunk of events from the query level's event list.
4203 * Keep any event list pointers elsewhere in the query level's data
4204 * structures in sync.
4205 * ----------
4206 */
4207 static void
4209 {
4215 /*
4216 * First, update any pointers in the per-table data, so that they won't be
4217 * dangling. Resetting obsoleted pointers to NULL will make
4218 * cancel_prior_stmt_triggers start from the list head, which is fine.
4219 */
4221 {
4226 {
4230 }
4231 }
4233 /* Now we can flush the head chunk */
4236 }
4239 /* ----------
4240 * AfterTriggerExecute()
4241 *
4242 * Fetch the required tuples back from the heap and fire one
4243 * single trigger function.
4244 *
4245 * Frequently, this will be fired many times in a row for triggers of
4246 * a single relation. Therefore, we cache the open relation and provide
4247 * fmgr lookup cache space at the caller level. (For triggers fired at
4248 * the end of a query, we can even piggyback on the executor's state.)
4249 *
4250 * When fired for a cross-partition update of a partitioned table, the old
4251 * tuple is fetched using 'src_relInfo' (the source leaf partition) and
4252 * the new tuple using 'dst_relInfo' (the destination leaf partition), though
4253 * both are converted into the root partitioned table's format before passing
4254 * to the trigger function.
4255 *
4256 * event: event currently being fired.
4257 * relInfo: result relation for event.
4258 * src_relInfo: source partition of a cross-partition update
4259 * dst_relInfo: its destination partition
4260 * trigdesc: working copy of rel's trigger info.
4261 * finfo: array of fmgr lookup cache entries (one per trigger in trigdesc).
4262 * instr: array of EXPLAIN ANALYZE instrumentation nodes (one per trigger),
4263 * or NULL if no instrumentation is wanted.
4264 * per_tuple_context: memory context to call trigger function in.
4265 * trig_tuple_slot1: scratch slot for tg_trigtuple (foreign tables only)
4266 * trig_tuple_slot2: scratch slot for tg_newtuple (foreign tables only)
4267 * ----------
4268 */
4269 static void
4271 AfterTriggerEvent event,
4277 MemoryContext per_tuple_context,
4280 {
4287 HeapTuple rettuple;
4292 /*
4293 * Locate trigger in trigdesc.
4294 */
4296 {
4298 {
4301 }
4302 }
4306 /*
4307 * If doing EXPLAIN ANALYZE, start charging time to this trigger. We want
4308 * to include time spent re-fetching tuples in the trigger cost.
4309 */
4313 /*
4314 * Fetch the required tuple(s).
4315 */
4317 {
4319 {
4323 trig_tuple_slot1))
4327 TRIGGER_EVENT_UPDATE &&
4329 trig_tuple_slot2))
4331 }
4332 /* fall through */
4335 /*
4336 * Store tuple in the slot so that tg_trigtuple does not reference
4337 * tuplestore memory. (It is formally possible for the trigger
4338 * function to queue trigger events that add to the same
4339 * tuplestore, which can push other tuples out of memory.) The
4340 * distinction is academic, because we start with a minimal tuple
4341 * that is stored as a heap tuple, constructed in different memory
4342 * context, in the slot anyway.
4343 */
4349 TRIGGER_EVENT_UPDATE)
4350 {
4354 }
4355 else
4356 {
4358 }
4363 {
4365 src_relInfo);
4369 SnapshotAny,
4370 src_slot))
4373 /*
4374 * Store the tuple fetched from the source partition into the
4375 * target (root partitioned) table slot, converting if needed.
4376 */
4378 {
4383 {
4385 src_slot,
4387 }
4388 else
4390 }
4391 else
4395 }
4396 else
4397 {
4399 }
4401 /* don't touch ctid2 if not there */
4405 {
4407 dst_relInfo);
4411 SnapshotAny,
4412 dst_slot))
4415 /*
4416 * Store the tuple fetched from the destination partition into
4417 * the target (root partitioned) table slot, converting if
4418 * needed.
4419 */
4421 {
4426 {
4428 dst_slot,
4430 }
4431 else
4433 }
4434 else
4438 }
4439 else
4440 {
4442 }
4443 }
4445 /*
4446 * Set up the tuplestore information to let the trigger have access to
4447 * transition tables. When we first make a transition table available to
4448 * a trigger, mark it "closed" so that it cannot change anymore. If any
4449 * additional events of the same type get queued in the current trigger
4450 * query level, they'll go into new transition tables.
4451 */
4454 {
4456 {
4459 else
4462 }
4465 {
4468 else
4471 }
4472 }
4474 /*
4475 * Setup the remaining trigger information
4476 */
4486 /*
4487 * Call the trigger and throw away any possibly returned updated tuple.
4488 * (Don't let ExecCallTriggerFunc measure EXPLAIN time.)
4489 */
4491 tgindx,
4492 finfo,
4493 NULL,
4494 per_tuple_context);
4500 /*
4501 * Release resources
4502 */
4508 /* don't clear slots' contents if foreign table */
4510 {
4515 }
4517 /*
4518 * If doing EXPLAIN ANALYZE, stop charging time to this trigger, and count
4519 * one "tuple returned" (really the number of firings).
4520 */
4523 }
4526 /*
4527 * afterTriggerMarkEvents()
4528 *
4529 * Scan the given event list for not yet invoked events. Mark the ones
4530 * that can be invoked now with the current firing ID.
4531 *
4532 * If move_list isn't NULL, events that are not to be invoked now are
4533 * transferred to move_list.
4534 *
4535 * When immediate_only is true, do not invoke currently-deferred triggers.
4536 * (This will be false only at main transaction exit.)
4537 *
4538 * Returns true if any invokable events were found.
4539 */
4540 static bool
4544 {
4547 AfterTriggerEvent event;
4551 {
4557 {
4558 /*
4559 * This trigger hasn't been called or scheduled yet. Check if we
4560 * should call it now.
4561 */
4563 {
4565 }
4566 else
4567 {
4568 /*
4569 * Mark it as to be fired in this firing cycle.
4570 */
4574 }
4575 }
4577 /*
4578 * If it's deferred, move it to move_list, if requested.
4579 */
4581 {
4583 /* add it to move_list */
4585 /* mark original copy "done" so we don't do it again */
4587 }
4588 }
4590 /*
4591 * We could allow deferred triggers if, before the end of the
4592 * security-restricted operation, we were to verify that a SET CONSTRAINTS
4593 * ... IMMEDIATE has fired all such triggers. For now, don't bother.
4594 */
4601 }
4603 /*
4604 * afterTriggerInvokeEvents()
4605 *
4606 * Scan the given event list for events that are marked as to be fired
4607 * in the current firing cycle, and fire them.
4608 *
4609 * If estate isn't NULL, we use its result relation info to avoid repeated
4610 * openings and closing of trigger target relations. If it is NULL, we
4611 * make one locally to cache the info in case there are multiple trigger
4612 * events per rel.
4613 *
4614 * When delete_ok is true, it's safe to delete fully-processed events.
4615 * (We are not very tense about that: we simply reset a chunk to be empty
4616 * if all its events got fired. The objective here is just to avoid useless
4617 * rescanning of events when a trigger queues new events during transaction
4618 * end, so it's not necessary to worry much about the case where only
4619 * some events are fired.)
4620 *
4621 * Returns true if no unfired events remain in the list (this allows us
4622 * to avoid repeating afterTriggerMarkEvents).
4623 */
4624 static bool
4626 CommandId firing_id,
4629 {
4632 MemoryContext per_tuple_context;
4642 /* Make a local EState if need be */
4644 {
4647 }
4649 /* Make a per-tuple memory context for trigger function calls */
4650 per_tuple_context =
4653 ALLOCSET_DEFAULT_SIZES);
4656 {
4657 AfterTriggerEvent event;
4661 {
4664 /*
4665 * Is it one for me to fire?
4666 */
4669 {
4673 /*
4674 * So let's fire it... but first, find the correct relation if
4675 * this is not the same relation as before.
4676 */
4678 {
4680 NULL);
4682 /* Catch calls with insufficient relcache refcounting */
4688 {
4692 }
4694 {
4699 }
4703 }
4705 /*
4706 * Look up source and destination partition result rels of a
4707 * cross-partition update event.
4708 */
4710 AFTER_TRIGGER_CP_UPDATE)
4711 {
4716 rInfo);
4719 rInfo);
4720 }
4721 else
4724 /*
4725 * Fire it. Note that the AFTER_TRIGGER_IN_PROGRESS flag is
4726 * still set, so recursive examinations of the event list
4727 * won't try to re-fire it.
4728 */
4734 /*
4735 * Mark the event as done.
4736 */
4739 }
4741 {
4742 /* something remains to be done */
4744 }
4745 }
4747 /* Clear the chunk if delete_ok and nothing left of interest */
4749 {
4753 /*
4754 * If it's last chunk, must sync event list's tailfree too. Note
4755 * that delete_ok must NOT be passed as true if there could be
4756 * additional AfterTriggerEventList values pointing at this event
4757 * list, since we'd fail to fix their copies of tailfree.
4758 */
4761 }
4762 }
4764 {
4767 }
4769 /* Release working resources */
4773 {
4777 }
4780 }
4783 /*
4784 * GetAfterTriggersTableData
4785 *
4786 * Find or create an AfterTriggersTableData struct for the specified
4787 * trigger event (relation + operation type). Ignore existing structs
4788 * marked "closed"; we don't want to put any additional tuples into them,
4789 * nor change their stmt-triggers-fired state.
4790 *
4791 * Note: the AfterTriggersTableData list is allocated in the current
4792 * (sub)transaction's CurTransactionContext. This is OK because
4793 * we don't need it to live past AfterTriggerEndQuery.
4794 */
4797 {
4800 MemoryContext oldcxt;
4803 /* Caller should have ensured query_depth is OK. */
4809 {
4814 }
4826 }
4828 /*
4829 * Returns a TupleTableSlot suitable for holding the tuples to be put
4830 * into AfterTriggersTableData's transition table tuplestores.
4831 */
4834 TupleDesc tupdesc)
4835 {
4836 /* Create it if not already done. */
4838 {
4839 MemoryContext oldcxt;
4841 /*
4842 * We need this slot only until AfterTriggerEndQuery, but making it
4843 * last till end-of-subxact is good enough. It'll be freed by
4844 * AfterTriggerFreeQuery(). However, the passed-in tupdesc might have
4845 * a different lifespan, so we'd better make a copy of that.
4846 */
4851 }
4854 }
4856 /*
4857 * MakeTransitionCaptureState
4858 *
4859 * Make a TransitionCaptureState object for the given TriggerDesc, target
4860 * relation, and operation type. The TCS object holds all the state needed
4861 * to decide whether to capture tuples in transition tables.
4862 *
4863 * If there are no triggers in 'trigdesc' that request relevant transition
4864 * tables, then return NULL.
4865 *
4866 * The resulting object can be passed to the ExecAR* functions. When
4867 * dealing with child tables, the caller can set tcs_original_insert_tuple
4868 * to avoid having to reconstruct the original tuple in the root table's
4869 * format.
4870 *
4871 * Note that we copy the flags from a parent table into this struct (rather
4872 * than subsequently using the relation's TriggerDesc directly) so that we can
4873 * use it to control collection of transition tuples from child tables.
4874 *
4875 * Per SQL spec, all operations of the same kind (INSERT/UPDATE/DELETE)
4876 * on the same table during one query should share one transition table.
4877 * Therefore, the Tuplestores are owned by an AfterTriggersTableData struct
4878 * looked up using the table OID + CmdType, and are merely referenced by
4879 * the TransitionCaptureState objects we hand out to callers.
4880 */
4881 TransitionCaptureState *
4883 {
4886 need_new_upd,
4887 need_old_del,
4888 need_new_ins;
4890 MemoryContext oldcxt;
4891 ResourceOwner saveResourceOwner;
4896 /* Detect which table(s) we need. */
4898 {
4920 /* keep compiler quiet */
4923 }
4927 /* Check state, like AfterTriggerSaveEvent. */
4931 /* Be sure we have enough space to record events at this query depth. */
4935 /*
4936 * Find or create an AfterTriggersTableData struct to hold the
4937 * tuplestore(s). If there's a matching struct but it's marked closed,
4938 * ignore it; we need a newer one.
4939 *
4940 * Note: the AfterTriggersTableData list, as well as the tuplestores, are
4941 * allocated in the current (sub)transaction's CurTransactionContext, and
4942 * the tuplestores are managed by the (sub)transaction's resource owner.
4943 * This is sufficient lifespan because we do not allow triggers using
4944 * transition tables to be deferrable; they will be fired during
4945 * AfterTriggerEndQuery, after which it's okay to delete the data.
4946 */
4949 /* Now create required tuplestore(s), if we don't have them already. */
4966 /* Now build the TransitionCaptureState struct, in caller's context */
4975 }
4978 /* ----------
4979 * AfterTriggerBeginXact()
4980 *
4981 * Called at transaction start (either BEGIN or implicit for single
4982 * statement outside of transaction block).
4983 * ----------
4984 */
4985 void
4987 {
4988 /*
4989 * Initialize after-trigger state structure to empty
4990 */
4994 /*
4995 * Verify that there is no leftover state remaining. If these assertions
4996 * trip, it means that AfterTriggerEndXact wasn't called or didn't clean
4997 * up properly.
4998 */
5006 }
5009 /* ----------
5010 * AfterTriggerBeginQuery()
5011 *
5012 * Called just before we start processing a single query within a
5013 * transaction (or subtransaction). Most of the real work gets deferred
5014 * until somebody actually tries to queue a trigger event.
5015 * ----------
5016 */
5017 void
5019 {
5020 /* Increase the query stack depth */
5022 }
5025 /* ----------
5026 * AfterTriggerEndQuery()
5027 *
5028 * Called after one query has been completely processed. At this time
5029 * we invoke all AFTER IMMEDIATE trigger events queued by the query, and
5030 * transfer deferred trigger events to the global deferred-trigger list.
5031 *
5032 * Note that this must be called BEFORE closing down the executor
5033 * with ExecutorEnd, because we make use of the EState's info about
5034 * target relations. Normally it is called from ExecutorFinish.
5035 * ----------
5036 */
5037 void
5039 {
5042 /* Must be inside a query, too */
5045 /*
5046 * If we never even got as far as initializing the event stack, there
5047 * certainly won't be any events, so exit quickly.
5048 */
5050 {
5053 }
5055 /*
5056 * Process all immediate-mode triggers queued by the query, and move the
5057 * deferred ones to the main list of deferred events.
5058 *
5059 * Notice that we decide which ones will be fired, and put the deferred
5060 * ones on the main list, before anything is actually fired. This ensures
5061 * reasonably sane behavior if a trigger function does SET CONSTRAINTS ...
5062 * IMMEDIATE: all events we have decided to defer will be available for it
5063 * to fire.
5064 *
5065 * We loop in case a trigger queues more events at the same query level.
5066 * Ordinary trigger functions, including all PL/pgSQL trigger functions,
5067 * will instead fire any triggers in a dedicated query level. Foreign key
5068 * enforcement triggers do add to the current query level, thanks to their
5069 * passing fire_triggers = false to SPI_execute_snapshot(). Other
5070 * C-language triggers might do likewise.
5071 *
5072 * If we find no firable events, we don't have to increment
5073 * firing_counter.
5074 */
5078 {
5080 {
5087 /*
5088 * Firing a trigger could result in query_stack being repalloc'd,
5089 * so we must recalculate qs after each afterTriggerInvokeEvents
5090 * call. Furthermore, it's unsafe to pass delete_ok = true here,
5091 * because that could cause afterTriggerInvokeEvents to try to
5092 * access qs->events after the stack has been repalloc'd.
5093 */
5096 /*
5097 * We'll need to scan the events list again. To reduce the cost
5098 * of doing so, get rid of completely-fired chunks. We know that
5099 * all events were marked IN_PROGRESS or DONE at the conclusion of
5100 * afterTriggerMarkEvents, so any still-interesting events must
5101 * have been added after that, and so must be in the chunk that
5102 * was then the tail chunk, or in later chunks. So, zap all
5103 * chunks before oldtail. This is approximately the same set of
5104 * events we would have gotten rid of by passing delete_ok = true.
5105 */
5109 }
5110 else
5112 }
5114 /* Release query-level-local storage, including tuplestores if any */
5118 }
5121 /*
5122 * AfterTriggerFreeQuery
5123 * Release subsidiary storage for a trigger query level.
5124 * This includes closing down tuplestores.
5125 * Note: it's important for this to be safe if interrupted by an error
5126 * and then called again for the same query level.
5127 */
5128 static void
5130 {
5135 /* Drop the trigger events */
5138 /* Drop FDW tuplestore if any */
5144 /* Release per-table subsidiary storage */
5147 {
5167 {
5172 }
5173 }
5175 /*
5176 * Now free the AfterTriggersTableData structs and list cells. Reset list
5177 * pointer first; if list_free_deep somehow gets an error, better to leak
5178 * that storage than have an infinite loop.
5179 */
5182 }
5185 /* ----------
5186 * AfterTriggerFireDeferred()
5187 *
5188 * Called just before the current transaction is committed. At this
5189 * time we invoke all pending DEFERRED triggers.
5190 *
5191 * It is possible for other modules to queue additional deferred triggers
5192 * during pre-commit processing; therefore xact.c may have to call this
5193 * multiple times.
5194 * ----------
5195 */
5196 void
5198 {
5202 /* Must not be inside a query */
5205 /*
5206 * If there are any triggers to fire, make sure we have set a snapshot for
5207 * them to use. (Since PortalRunUtility doesn't set a snap for COMMIT, we
5208 * can't assume ActiveSnapshot is valid on entry.)
5209 */
5212 {
5215 }
5217 /*
5218 * Run all the remaining triggers. Loop until they are all gone, in case
5219 * some trigger queues more for us to do.
5220 */
5222 {
5227 }
5229 /*
5230 * We don't bother freeing the event list, since it will go away anyway
5231 * (and more efficiently than via pfree) in AfterTriggerEndXact.
5232 */
5236 }
5239 /* ----------
5240 * AfterTriggerEndXact()
5241 *
5242 * The current transaction is finishing.
5243 *
5244 * Any unfired triggers are canceled so we simply throw
5245 * away anything we know.
5246 *
5247 * Note: it is possible for this to be called repeatedly in case of
5248 * error during transaction abort; therefore, do not complain if
5249 * already closed down.
5250 * ----------
5251 */
5252 void
5254 {
5255 /*
5256 * Forget the pending-events list.
5257 *
5258 * Since all the info is in TopTransactionContext or children thereof, we
5259 * don't really need to do anything to reclaim memory. However, the
5260 * pending-events list could be large, and so it's useful to discard it as
5261 * soon as possible --- especially if we are aborting because we ran out
5262 * of memory for the list!
5263 */
5265 {
5271 }
5273 /*
5274 * Forget any subtransaction state as well. Since this can't be very
5275 * large, we let the eventual reset of TopTransactionContext free the
5276 * memory instead of doing it here.
5277 */
5282 /*
5283 * Forget the query stack and constraint-related state information. As
5284 * with the subtransaction state information, we don't bother freeing the
5285 * memory here.
5286 */
5291 /* No more afterTriggers manipulation until next transaction starts. */
5293 }
5295 /*
5296 * AfterTriggerBeginSubXact()
5297 *
5298 * Start a subtransaction.
5299 */
5300 void
5302 {
5305 /*
5306 * Allocate more space in the trans_stack if needed. (Note: because the
5307 * minimum nest level of a subtransaction is 2, we waste the first couple
5308 * entries of the array; not worth the notational effort to avoid it.)
5309 */
5311 {
5313 {
5314 /* Arbitrarily initialize for max of 8 subtransaction levels */
5319 }
5320 else
5321 {
5322 /* repalloc will keep the stack in the same context */
5329 }
5330 }
5332 /*
5333 * Push the current information into the stack. The SET CONSTRAINTS state
5334 * is not saved until/unless changed. Likewise, we don't make a
5335 * per-subtransaction event context until needed.
5336 */
5341 }
5343 /*
5344 * AfterTriggerEndSubXact()
5345 *
5346 * The current subtransaction is ending.
5347 */
5348 void
5350 {
5352 SetConstraintState state;
5353 AfterTriggerEvent event;
5355 CommandId subxact_firing_id;
5357 /*
5358 * Pop the prior state if needed.
5359 */
5361 {
5363 /* If we saved a prior state, we don't need it anymore */
5367 /* this avoids double pfree if error later: */
5371 }
5372 else
5373 {
5374 /*
5375 * Aborting. It is possible subxact start failed before calling
5376 * AfterTriggerBeginSubXact, in which case we mustn't risk touching
5377 * trans_stack levels that aren't there.
5378 */
5382 /*
5383 * Release query-level storage for queries being aborted, and restore
5384 * query_depth to its pre-subxact value. This assumes that a
5385 * subtransaction will not add events to query levels started in a
5386 * earlier transaction state.
5387 */
5389 {
5393 }
5397 /*
5398 * Restore the global deferred-event list to its former length,
5399 * discarding any events queued by the subxact.
5400 */
5404 /*
5405 * Restore the trigger state. If the saved state is NULL, then this
5406 * subxact didn't save it, so it doesn't need restoring.
5407 */
5410 {
5413 }
5414 /* this avoids double pfree if error later: */
5417 /*
5418 * Scan for any remaining deferred events that were marked DONE or IN
5419 * PROGRESS by this subxact or a child, and un-mark them. We can
5420 * recognize such events because they have a firing ID greater than or
5421 * equal to the firing_counter value we saved at subtransaction start.
5422 * (This essentially assumes that the current subxact includes all
5423 * subxacts started after it.)
5424 */
5427 {
5432 {
5436 }
5437 }
5438 }
5439 }
5441 /*
5442 * Get the transition table for the given event and depending on whether we are
5443 * processing the old or the new tuple.
5444 */
5450 {
5457 /*
5458 * For INSERT events NEW should be non-NULL, for DELETE events OLD should
5459 * be non-NULL, whereas for UPDATE events normally both OLD and NEW are
5460 * non-NULL. But for UPDATE events fired for capturing transition tuples
5461 * during UPDATE partition-key row movement, OLD is NULL when the event is
5462 * for a row being inserted, whereas NEW is NULL when the event is for a
5463 * row being deleted.
5464 */
5471 {
5477 }
5479 {
5485 }
5488 }
5490 /*
5491 * Add the given heap tuple to the given tuplestore, applying the conversion
5492 * map if necessary.
5493 *
5494 * If original_insert_tuple is given, we can add that tuple without conversion.
5495 */
5496 static void
5503 {
5506 /*
5507 * Nothing needs to be done if we don't have a tuplestore.
5508 */
5515 {
5522 }
5523 else
5525 }
5527 /* ----------
5528 * AfterTriggerEnlargeQueryState()
5529 *
5530 * Prepare the necessary state so that we can record AFTER trigger events
5531 * queued by a query. It is allowed to have nested queries within a
5532 * (sub)transaction, so we need to have separate state for each query
5533 * nesting level.
5534 * ----------
5535 */
5536 static void
5538 {
5544 {
5551 }
5552 else
5553 {
5554 /* repalloc will keep the stack in the same context */
5563 }
5565 /* Initialize new array entries to empty */
5567 {
5577 }
5578 }
5580 /*
5581 * Create an empty SetConstraintState with room for numalloc trigstates
5582 */
5583 static SetConstraintState
5585 {
5586 SetConstraintState state;
5588 /* Behave sanely with numalloc == 0 */
5592 /*
5593 * We assume that zeroing will correctly initialize the state values.
5594 */
5603 }
5605 /*
5606 * Copy a SetConstraintState
5607 */
5608 static SetConstraintState
5610 {
5611 SetConstraintState state;
5622 }
5624 /*
5625 * Add a per-trigger item to a SetConstraintState. Returns possibly-changed
5626 * pointer to the state object (it will change if we have to repalloc).
5627 */
5628 static SetConstraintState
5631 {
5633 {
5643 }
5650 }
5652 /* ----------
5653 * AfterTriggerSetState()
5654 *
5655 * Execute the SET CONSTRAINTS ... utility command.
5656 * ----------
5657 */
5658 void
5660 {
5663 /* If we haven't already done so, initialize our state. */
5667 /*
5668 * If in a subtransaction, and we didn't save the current state already,
5669 * save it so it can be restored if the subtransaction aborts.
5670 */
5673 {
5676 }
5678 /*
5679 * Handle SET CONSTRAINTS ALL ...
5680 */
5682 {
5683 /*
5684 * Forget any previous SET CONSTRAINTS commands in this transaction.
5685 */
5688 /*
5689 * Set the per-transaction ALL state to known.
5690 */
5693 }
5694 else
5695 {
5696 Relation conrel;
5697 Relation tgrel;
5702 /*
5703 * Handle SET CONSTRAINTS constraint-name [, ...]
5704 *
5705 * First, identify all the named constraints and make a list of their
5706 * OIDs. Since, unlike the SQL spec, we allow multiple constraints of
5707 * the same name within a schema, the specifications are not
5708 * necessarily unique. Our strategy is to target all matching
5709 * constraints within the first search-path schema that has any
5710 * matches, but disregard matches in schemas beyond the first match.
5711 * (This is a bit odd but it's the historical behavior.)
5712 *
5713 * A constraint in a partitioned table may have corresponding
5714 * constraints in the partitions. Grab those too.
5715 */
5719 {
5726 {
5733 }
5735 /*
5736 * If we're given the schema name with the constraint, look only
5737 * in that schema. If given a bare constraint name, use the
5738 * search path to find the first matching constraint.
5739 */
5741 {
5746 }
5747 else
5748 {
5750 }
5754 {
5756 SysScanDesc conscan;
5758 HeapTuple tup;
5761 Anum_pg_constraint_conname,
5765 Anum_pg_constraint_connamespace,
5773 {
5784 }
5788 /*
5789 * Once we've found a matching constraint we do not search
5790 * later parts of the search path.
5791 */
5794 }
5798 /*
5799 * Not found ?
5800 */
5806 }
5808 /*
5809 * Scan for any possible descendants of the constraints. We append
5810 * whatever we find to the same list that we're scanning; this has the
5811 * effect that we create new scans for those, too, so if there are
5812 * further descendents, we'll also catch them.
5813 */
5815 {
5817 ScanKeyData key;
5818 SysScanDesc scan;
5819 HeapTuple tuple;
5822 Anum_pg_constraint_conparentid,
5829 {
5833 }
5836 }
5840 /*
5841 * Now, locate the trigger(s) implementing each of these constraints,
5842 * and make a list of their OIDs.
5843 */
5847 {
5849 ScanKeyData skey;
5850 SysScanDesc tgscan;
5851 HeapTuple htup;
5854 Anum_pg_trigger_tgconstraint,
5862 {
5865 /*
5866 * Silently skip triggers that are marked as non-deferrable in
5867 * pg_trigger. This is not an error condition, since a
5868 * deferrable RI constraint may have some non-deferrable
5869 * actions.
5870 */
5873 }
5876 }
5880 /*
5881 * Now we can set the trigger states of individual triggers for this
5882 * xact.
5883 */
5885 {
5892 {
5894 {
5898 }
5899 }
5901 {
5904 }
5905 }
5906 }
5908 /*
5909 * SQL99 requires that when a constraint is set to IMMEDIATE, any deferred
5910 * checks against that constraint must be made when the SET CONSTRAINTS
5911 * command is executed -- i.e. the effects of the SET CONSTRAINTS command
5912 * apply retroactively. We've updated the constraints state, so scan the
5913 * list of previously deferred events to fire any that have now become
5914 * immediate.
5915 *
5916 * Obviously, if this was SET ... DEFERRED then it can't have converted
5917 * any unfired events to immediate, so we need do nothing in that case.
5918 */
5920 {
5925 {
5928 /*
5929 * Make sure a snapshot has been established in case trigger
5930 * functions need one. Note that we avoid setting a snapshot if
5931 * we don't find at least one trigger that has to be fired now.
5932 * This is so that BEGIN; SET CONSTRAINTS ...; SET TRANSACTION
5933 * ISOLATION LEVEL SERIALIZABLE; ... works properly. (If we are
5934 * at the start of a transaction it's not possible for any trigger
5935 * events to be queued yet.)
5936 */
5938 {
5941 }
5943 /*
5944 * We can delete fired events if we are at top transaction level,
5945 * but we'd better not if inside a subtransaction, since the
5946 * subtransaction could later get rolled back.
5947 */
5951 }
5955 }
5956 }
5958 /* ----------
5959 * AfterTriggerPendingOnRel()
5960 * Test to see if there are any pending after-trigger events for rel.
5961 *
5962 * This is used by TRUNCATE, CLUSTER, ALTER TABLE, etc to detect whether
5963 * it is unsafe to perform major surgery on a relation. Note that only
5964 * local pending events are examined. We assume that having exclusive lock
5965 * on a rel guarantees there are no unserviced events in other backends ---
5966 * but having a lock does not prevent there being such events in our own.
5967 *
5968 * In some scenarios it'd be reasonable to remove pending events (more
5969 * specifically, mark them DONE by the current subxact) but without a lot
5970 * of knowledge of the trigger semantics we can't do this in general.
5971 * ----------
5972 */
5973 bool
5975 {
5976 AfterTriggerEvent event;
5980 /* Scan queued events */
5982 {
5985 /*
5986 * We can ignore completed events. (Even if a DONE flag is rolled
5987 * back by subxact abort, it's OK because the effects of the TRUNCATE
5988 * or whatever must get rolled back too.)
5989 */
5995 }
5997 /*
5998 * Also scan events queued by incomplete queries. This could only matter
5999 * if TRUNCATE/etc is executed by a function or trigger within an updating
6000 * query on the same relation, which is pretty perverse, but let's check.
6001 */
6002 for (depth = 0; depth <= afterTriggers.query_depth && depth < afterTriggers.maxquerydepth; depth++)
6003 {
6005 {
6013 }
6014 }
6017 }
6019 /* ----------
6020 * AfterTriggerSaveEvent()
6021 *
6022 * Called by ExecA[RS]...Triggers() to queue up the triggers that should
6023 * be fired for an event.
6024 *
6025 * NOTE: this is called whenever there are any triggers associated with
6026 * the event (even if they are disabled). This function decides which
6027 * triggers actually need to be queued. It is also called after each row,
6028 * even if there are no triggers for that event, if there are any AFTER
6029 * STATEMENT triggers for the statement which use transition tables, so that
6030 * the transition tuplestores can be built. Furthermore, if the transition
6031 * capture is happening for UPDATEd rows being moved to another partition due
6032 * to the partition-key being changed, then this function is called once when
6033 * the row is deleted (to capture OLD row), and once when the row is inserted
6034 * into another partition (to capture NEW row). This is done separately because
6035 * DELETE and INSERT happen on different tables.
6036 *
6037 * Transition tuplestores are built now, rather than when events are pulled
6038 * off of the queue because AFTER ROW triggers are allowed to select from the
6039 * transition tables for the statement.
6040 *
6041 * This contains special support to queue the update events for the case where
6042 * a partitioned table undergoing a cross-partition update may have foreign
6043 * keys pointing into it. Normally, a partitioned table's row triggers are
6044 * not fired because the leaf partition(s) which are modified as a result of
6045 * the operation on the partitioned table contain the same triggers which are
6046 * fired instead. But that general scheme can cause problematic behavior with
6047 * foreign key triggers during cross-partition updates, which are implemented
6048 * as DELETE on the source partition followed by INSERT into the destination
6049 * partition. Specifically, firing DELETE triggers would lead to the wrong
6050 * foreign key action to be enforced considering that the original command is
6051 * UPDATE; in this case, this function is called with relinfo as the
6052 * partitioned table, and src_partinfo and dst_partinfo referring to the
6053 * source and target leaf partitions, respectively.
6054 *
6055 * is_crosspart_update is true either when a DELETE event is fired on the
6056 * source partition (which is to be ignored) or an UPDATE event is fired on
6057 * the root partitioned table.
6058 * ----------
6059 */
6060 static void
6069 {
6072 AfterTriggerEventData new_event;
6073 AfterTriggerSharedData new_shared;
6080 /*
6081 * Check state. We use a normal test not Assert because it is possible to
6082 * reach here in the wrong state given misconfigured RI triggers, in
6083 * particular deferring a cascade action trigger.
6084 */
6088 /* Be sure we have enough space to record events at this query depth. */
6092 /*
6093 * If the directly named relation has any triggers with transition tables,
6094 * then we need to capture transition tuples.
6095 */
6097 {
6100 /*
6101 * Capture the old tuple in the appropriate transition table based on
6102 * the event.
6103 */
6105 {
6109 oldslot,
6110 NULL,
6111 transition_capture);
6114 }
6116 /*
6117 * Capture the new tuple in the appropriate transition table based on
6118 * the event.
6119 */
6121 {
6125 NULL,
6126 newslot,
6127 transition_capture);
6130 }
6132 /*
6133 * If transition tables are the only reason we're here, return. As
6134 * mentioned above, we can also be here during update tuple routing in
6135 * presence of transition tables, in which case this function is
6136 * called separately for OLD and NEW, so we expect exactly one of them
6137 * to be NULL.
6138 */
6145 }
6147 /*
6148 * We normally don't see partitioned tables here for row level triggers
6149 * except in the special case of a cross-partition update. In that case,
6150 * nodeModifyTable.c:ExecCrossPartitionUpdateForeignKey() calls here to
6151 * queue an update event on the root target partitioned table, also
6152 * passing the source and destination partitions and their tuples.
6153 */
6160 /*
6161 * Validate the event code and collect the associated tuple CTIDs.
6162 *
6163 * The event code will be used both as a bitmask and an array offset, so
6164 * validation is important to make sure we don't walk off the edge of our
6165 * arrays.
6166 *
6167 * Also, if we're considering statement-level triggers, check whether we
6168 * already queued a set of them for this event, and cancel the prior set
6169 * if so. This preserves the behavior that statement-level triggers fire
6170 * just once per statement and fire after row-level triggers.
6171 */
6173 {
6177 {
6182 }
6183 else
6184 {
6191 }
6196 {
6201 }
6202 else
6203 {
6210 }
6215 {
6221 /*
6222 * Also remember the OIDs of partitions to fetch these tuples
6223 * out of later in AfterTriggerExecute().
6224 */
6226 {
6232 }
6233 }
6234 else
6235 {
6242 }
6255 }
6257 /* Determine flags */
6259 {
6261 {
6264 else
6266 }
6267 else
6269 }
6271 /* else, we'll initialize ate_flags for each trigger */
6275 /*
6276 * Must convert/copy the source and destination partition tuples into the
6277 * root partitioned table's format/slot, because the processing in the
6278 * loop below expects both oldslot and newslot tuples to be in that form.
6279 */
6281 {
6289 oldslot,
6290 rootslot);
6291 else
6298 newslot,
6299 rootslot);
6300 else
6302 }
6305 {
6309 tgtype_level,
6310 TRIGGER_TYPE_AFTER,
6311 tgtype_event))
6318 {
6320 {
6323 }
6324 else
6325 /* subsequent event for the same tuple */
6327 }
6329 /*
6330 * If the trigger is a foreign key enforcement trigger, there are
6331 * certain cases where we can skip queueing the event because we can
6332 * tell by inspection that the FK constraint will still pass. There
6333 * are also some cases during cross-partition updates of a partitioned
6334 * table where queuing the event can be skipped.
6335 */
6337 {
6339 {
6342 /*
6343 * For cross-partitioned updates of partitioned PK table,
6344 * skip the event fired by the component delete on the
6345 * source leaf partition unless the constraint originates
6346 * in the partition itself (!tgisclone), because the
6347 * update event that will be fired on the root
6348 * (partitioned) target table will be used to perform the
6349 * necessary foreign key enforcement action.
6350 */
6356 /* Update or delete on trigger's PK table */
6359 {
6360 /* skip queuing this event */
6362 }
6367 /*
6368 * Update on trigger's FK table. We can skip the update
6369 * event fired on a partitioned table during a
6370 * cross-partition of that table, because the insert event
6371 * that is fired on the destination leaf partition would
6372 * suffice to perform the necessary foreign key check.
6373 * Moreover, RI_FKey_fk_upd_check_required() expects to be
6374 * passed a tuple that contains system attributes, most of
6375 * which are not present in the virtual slot belonging to
6376 * a partitioned table.
6377 */
6381 {
6382 /* skip queuing this event */
6384 }
6389 /*
6390 * Not an FK trigger. No need to queue the update event
6391 * fired during a cross-partitioned update of a
6392 * partitioned table, because the same row trigger must be
6393 * present in the leaf partition(s) that are affected as
6394 * part of this update and the events fired on them are
6395 * queued instead.
6396 */
6401 }
6402 }
6404 /*
6405 * If the trigger is a deferred unique constraint check trigger, only
6406 * queue it if the unique constraint was potentially violated, which
6407 * we know from index insertion time.
6408 */
6410 {
6413 }
6415 /*
6416 * Fill in event structure and add it to the current query's queue.
6417 * Note we set ats_table to NULL whenever this trigger doesn't use
6418 * transition tables, to improve sharability of the shared event data.
6419 */
6431 else
6437 }
6439 /*
6440 * Finally, spool any foreign tuple(s). The tuplestore squashes them to
6441 * minimal tuples, so this loses any system columns. The executor lost
6442 * those columns before us, for an unrelated reason, so this is fine.
6443 */
6445 {
6450 }
6451 }
6453 /*
6454 * Detect whether we already queued BEFORE STATEMENT triggers for the given
6455 * relation + operation, and set the flag so the next call will report "true".
6456 */
6457 static bool
6459 {
6463 /* Check state, like AfterTriggerSaveEvent. */
6467 /* Be sure we have enough space to record events at this query depth. */
6471 /*
6472 * We keep this state in the AfterTriggersTableData that also holds
6473 * transition tables for the relation + operation. In this way, if we are
6474 * forced to make a new set of transition tables because more tuples get
6475 * entered after we've already fired triggers, we will allow a new set of
6476 * statement triggers to get queued.
6477 */
6482 }
6484 /*
6485 * If we previously queued a set of AFTER STATEMENT triggers for the given
6486 * relation + operation, and they've not been fired yet, cancel them. The
6487 * caller will queue a fresh set that's after any row-level triggers that may
6488 * have been queued by the current sub-statement, preserving (as much as
6489 * possible) the property that AFTER ROW triggers fire before AFTER STATEMENT
6490 * triggers, and that the latter only fire once. This deals with the
6491 * situation where several FK enforcement triggers sequentially queue triggers
6492 * for the same table into the same trigger query level. We can't fully
6493 * prevent odd behavior though: if there are AFTER ROW triggers taking
6494 * transition tables, we don't want to change the transition tables once the
6495 * first such trigger has seen them. In such a case, any additional events
6496 * will result in creating new transition tables and allowing new firings of
6497 * statement triggers.
6498 *
6499 * This also saves the current event list location so that a later invocation
6500 * of this function can cheaply find the triggers we're about to queue and
6501 * cancel them.
6502 */
6503 static void
6505 {
6509 /*
6510 * We keep this state in the AfterTriggersTableData that also holds
6511 * transition tables for the relation + operation. In this way, if we are
6512 * forced to make a new set of transition tables because more tuples get
6513 * entered after we've already fired triggers, we will allow a new set of
6514 * statement triggers to get queued without canceling the old ones.
6515 */
6519 {
6520 /*
6521 * We want to start scanning from the tail location that existed just
6522 * before we inserted any statement triggers. But the events list
6523 * might've been entirely empty then, in which case scan from the
6524 * current head.
6525 */
6526 AfterTriggerEvent event;
6530 {
6533 }
6534 else
6535 {
6538 }
6541 {
6545 {
6548 /*
6549 * Exit loop when we reach events that aren't AS triggers for
6550 * the target relation.
6551 */
6560 /* OK, mark it DONE */
6563 }
6564 /* signal we must reinitialize event ptr for next chunk */
6566 }
6567 }
6568 done:
6570 /* In any case, save current insertion point for next time */
6573 }
6575 /*
6576 * GUC assign_hook for session_replication_role
6577 */
6578 void
6580 {
6581 /*
6582 * Must flush the plan cache when changing replication role; but don't
6583 * flush unnecessarily.
6584 */
6587 }
6589 /*
6590 * SQL function pg_trigger_depth()
6591 */
6592 Datum
6594 {
6596 }