| blob | acf3e4a3f1f7de95cf909ea5e4731201d4fba7e2 |
1 /*-------------------------------------------------------------------------
2 *
3 * trigger.c
4 * PostgreSQL TRIGGERs support code.
5 *
6 * Portions Copyright (c) 1996-2025, 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,
822 NULL,
823 NULL,
824 NULL,
825 NULL,
829 NULL,
834 NULL,
840 }
842 /*
843 * If trigger is internally generated, modify the provided trigger name to
844 * ensure uniqueness by appending the trigger OID. (Callers will usually
845 * supply a simple constant trigger name in these cases.)
846 */
848 {
852 }
853 else
854 {
855 /* user-defined trigger; use the specified trigger name as-is */
857 }
859 /*
860 * Build the new pg_trigger tuple.
861 */
880 {
887 {
892 {
894 len++;
895 }
896 }
900 {
905 {
909 }
911 }
915 }
916 else
917 {
921 }
923 /* build column number array if it's a column-specific trigger */
927 else
928 {
934 {
936 int16 attnum;
939 /* Lookup column name. System columns are not allowed */
947 /* Check for duplicates */
949 {
954 name)));
955 }
958 }
959 }
963 /* set tgqual if trigger has WHEN clause */
966 else
972 else
977 else
980 /*
981 * Insert or replace tuple in pg_trigger.
982 */
984 {
987 }
988 else
989 {
990 HeapTuple newtup;
995 }
1008 /*
1009 * Update relation's pg_class entry; if necessary; and if not, send an SI
1010 * message to make other backends (and this one) rebuild relcache entries.
1011 */
1019 {
1025 }
1026 else
1032 /*
1033 * If we're replacing a trigger, flush all the old dependencies before
1034 * recording new ones.
1035 */
1039 /*
1040 * Record dependencies for trigger. Always place a normal dependency on
1041 * the function.
1042 */
1053 {
1054 /*
1055 * Internally-generated trigger for a constraint, so make it an
1056 * internal dependency of the constraint. We can skip depending on
1057 * the relation(s), as there'll be an indirect dependency via the
1058 * constraint.
1059 */
1064 }
1065 else
1066 {
1067 /*
1068 * User CREATE TRIGGER, so place dependencies. We make trigger be
1069 * auto-dropped if its relation is dropped or if the FK relation is
1070 * dropped. (Auto drop is compatible with our pre-7.3 behavior.)
1071 */
1078 {
1083 }
1084 /* Not possible to have an index dependency in this case */
1087 /*
1088 * If it's a user-specified constraint trigger, make the constraint
1089 * internally dependent on the trigger instead of vice versa.
1090 */
1092 {
1097 }
1099 /*
1100 * If it's a partition trigger, create the partition dependencies.
1101 */
1103 {
1108 }
1109 }
1111 /* If column-specific trigger, add normal dependencies on columns */
1113 {
1119 {
1122 }
1123 }
1125 /*
1126 * If it has a WHEN clause, add dependencies on objects mentioned in the
1127 * expression (eg, functions, as well as any columns used).
1128 */
1131 DEPENDENCY_NORMAL);
1133 /* Post creation hook for new trigger */
1135 isInternal);
1137 /*
1138 * Lastly, create the trigger on child relations, if needed.
1139 */
1141 {
1144 MemoryContext oldcxt,
1145 perChildCxt;
1149 ALLOCSET_SMALL_SIZES);
1151 /*
1152 * We don't currently expect to be called with a valid indexOid. If
1153 * that ever changes then we'll need to write code here to find the
1154 * corresponding child index.
1155 */
1160 /* Iterate to create the trigger on each existing partition */
1162 {
1164 Relation childTbl;
1169 /*
1170 * Initialize our fabricated parse node by copying the original
1171 * one, then resetting fields that we pass separately.
1172 */
1177 /* If there is a WHEN clause, create a modified copy of it */
1195 }
1199 }
1201 /* Keep lock on target rel until end of xact */
1205 }
1207 /*
1208 * TriggerSetParentTrigger
1209 * Set a partition's trigger as child of its parent trigger,
1210 * or remove the linkage if parentTrigId is InvalidOid.
1211 *
1212 * This updates the constraint's pg_trigger row to show it as inherited, and
1213 * adds PARTITION dependencies to prevent the trigger from being deleted
1214 * on its own. Alternatively, reverse that.
1215 */
1216 void
1218 Oid childTrigId,
1219 Oid parentTrigId,
1220 Oid childTableId)
1221 {
1222 SysScanDesc tgscan;
1224 Form_pg_trigger trigForm;
1225 HeapTuple tuple,
1226 newtup;
1227 ObjectAddress depender;
1228 ObjectAddress referenced;
1230 /*
1231 * Find the trigger to delete.
1232 */
1234 Anum_pg_trigger_oid,
1247 {
1248 /* don't allow setting parent for a constraint that already has one */
1251 childTrigId);
1264 }
1265 else
1266 {
1272 TriggerRelationId,
1273 DEPENDENCY_PARTITION_PRI);
1275 RelationRelationId,
1276 DEPENDENCY_PARTITION_SEC);
1277 }
1281 }
1284 /*
1285 * Guts of trigger deletion.
1286 */
1287 void
1289 {
1290 Relation tgrel;
1291 SysScanDesc tgscan;
1293 HeapTuple tup;
1294 Oid relid;
1295 Relation rel;
1299 /*
1300 * Find the trigger to delete.
1301 */
1303 Anum_pg_trigger_oid,
1314 /*
1315 * Open and exclusive-lock the relation the trigger belongs to.
1316 */
1337 /*
1338 * Delete the pg_trigger tuple.
1339 */
1345 /*
1346 * We do not bother to try to determine whether any other triggers remain,
1347 * which would be needed in order to decide whether it's safe to clear the
1348 * relation's relhastriggers. (In any case, there might be a concurrent
1349 * process adding new triggers.) Instead, just force a relcache inval to
1350 * make other backends (and this one too!) rebuild their relcache entries.
1351 * There's no great harm in leaving relhastriggers true even if there are
1352 * no triggers left.
1353 */
1356 /* Keep lock on trigger's rel until end of xact */
1358 }
1360 /*
1361 * get_trigger_oid - Look up a trigger by name to find its OID.
1362 *
1363 * If missing_ok is false, throw an error if trigger not found. If
1364 * true, just return InvalidOid.
1365 */
1366 Oid
1368 {
1369 Relation tgrel;
1371 SysScanDesc tgscan;
1372 HeapTuple tup;
1373 Oid oid;
1375 /*
1376 * Find the trigger, verify permissions, set up object address
1377 */
1381 Anum_pg_trigger_tgrelid,
1385 Anum_pg_trigger_tgname,
1395 {
1402 }
1403 else
1404 {
1406 }
1411 }
1413 /*
1414 * Perform permissions and integrity checks before acquiring a relation lock.
1415 */
1416 static void
1419 {
1420 HeapTuple tuple;
1421 Form_pg_class form;
1428 /* only tables and views can have triggers */
1438 /* you must own the table to rename one of its triggers */
1448 }
1450 /*
1451 * renametrig - changes the name of a trigger on a relation
1452 *
1453 * trigger name is changed in trigger catalog.
1454 * No record of the previous name is kept.
1455 *
1456 * get proper relrelation from relation catalog (if not arg)
1457 * scan trigger catalog
1458 * for name conflict (within rel)
1459 * for original trigger (if not arg)
1460 * modify tgname in trigger tuple
1461 * update row in catalog
1462 */
1463 ObjectAddress
1465 {
1466 Oid tgoid;
1467 Relation targetrel;
1468 Relation tgrel;
1469 HeapTuple tuple;
1470 SysScanDesc tgscan;
1472 Oid relid;
1473 ObjectAddress address;
1475 /*
1476 * Look up name, check permissions, and acquire lock (which we will NOT
1477 * release until end of transaction).
1478 */
1481 RangeVarCallbackForRenameTrigger,
1482 NULL);
1484 /* Have lock already, so just need to build relcache entry. */
1487 /*
1488 * On partitioned tables, this operation recurses to partitions. Lock all
1489 * tables upfront.
1490 */
1496 /*
1497 * Search for the trigger to modify.
1498 */
1500 Anum_pg_trigger_tgrelid,
1504 Anum_pg_trigger_tgname,
1510 {
1511 Form_pg_trigger trigform;
1516 /*
1517 * If the trigger descends from a trigger on a parent partitioned
1518 * table, reject the rename. We don't allow a trigger in a partition
1519 * to differ in name from that of its parent: that would lead to an
1520 * inconsistency that pg_dump would not reproduce.
1521 */
1531 /* Rename the trigger on this relation ... */
1535 /* ... and if it is partitioned, recurse to its partitions */
1537 {
1541 {
1546 }
1547 }
1548 }
1549 else
1550 {
1555 }
1563 /*
1564 * Close rel, but keep exclusive lock!
1565 */
1569 }
1571 /*
1572 * Subroutine for renametrig -- perform the actual work of renaming one
1573 * trigger on one table.
1574 *
1575 * If the trigger has a name different from the expected one, raise a
1576 * NOTICE about it.
1577 */
1578 static void
1581 {
1582 HeapTuple tuple;
1583 Form_pg_trigger tgform;
1585 SysScanDesc tgscan;
1587 /* If the trigger already has the new name, nothing to do. */
1592 /*
1593 * Before actually trying the rename, search for triggers with the same
1594 * name. The update would fail with an ugly message in that case, and it
1595 * is better to throw a nicer error.
1596 */
1598 Anum_pg_trigger_tgrelid,
1602 Anum_pg_trigger_tgname,
1614 /*
1615 * The target name is free; update the existing pg_trigger tuple with it.
1616 */
1620 /*
1621 * If the trigger has a name different from what we expected, let the user
1622 * know. (We can proceed anyway, since we must have reached here following
1623 * a tgparentid link.)
1624 */
1637 /*
1638 * Invalidate relation's relcache entry so that other backends (and this
1639 * one too!) are sent SI message to make them rebuild relcache entries.
1640 * (Ideally this should happen automatically...)
1641 */
1643 }
1645 /*
1646 * Subroutine for renametrig -- Helper for recursing to partitions when
1647 * renaming triggers on a partitioned table.
1648 */
1649 static void
1652 {
1653 SysScanDesc tgscan;
1654 ScanKeyData key;
1655 HeapTuple tuple;
1657 /*
1658 * Given a relation and the OID of a trigger on parent relation, find the
1659 * corresponding trigger in the child and rename that trigger to the given
1660 * name.
1661 */
1663 Anum_pg_trigger_tgrelid,
1669 {
1671 Relation partitionRel;
1678 /* Rename the trigger on this partition */
1681 /* And if this relation is partitioned, recurse to its partitions */
1683 {
1688 {
1693 }
1694 }
1697 /* There should be at most one matching tuple */
1699 }
1701 }
1703 /*
1704 * EnableDisableTrigger()
1705 *
1706 * Called by ALTER TABLE ENABLE/DISABLE [ REPLICA | ALWAYS ] TRIGGER
1707 * to change 'tgenabled' field for the specified trigger(s)
1708 *
1709 * rel: relation to process (caller must hold suitable lock on it)
1710 * tgname: name of trigger to process, or NULL to scan all triggers
1711 * tgparent: if not zero, process only triggers with this tgparentid
1712 * fires_when: new value for tgenabled field. In addition to generic
1713 * enablement/disablement, this also defines when the trigger
1714 * should be fired in session replication roles.
1715 * skip_system: if true, skip "system" triggers (constraint triggers)
1716 * recurse: if true, recurse to partitions
1717 *
1718 * Caller should have checked permissions for the table; here we also
1719 * enforce that superuser privilege is required to alter the state of
1720 * system triggers
1721 */
1722 void
1725 LOCKMODE lockmode)
1726 {
1727 Relation tgrel;
1730 SysScanDesc tgscan;
1731 HeapTuple tuple;
1735 /* Scan the relevant entries in pg_triggers */
1739 Anum_pg_trigger_tgrelid,
1743 {
1745 Anum_pg_trigger_tgname,
1749 }
1750 else
1759 {
1766 {
1767 /* system trigger ... ok to process? */
1775 }
1780 {
1781 /* need to change this one ... make a copy to scribble on */
1792 }
1794 /*
1795 * When altering FOR EACH ROW triggers on a partitioned table, do the
1796 * same on the partitions as well, unless ONLY is specified.
1797 *
1798 * Note that we recurse even if we didn't change the trigger above,
1799 * because the partitions' copy of the trigger may have a different
1800 * value of tgenabled than the parent's trigger and thus might need to
1801 * be changed.
1802 */
1806 {
1811 {
1812 Relation part;
1815 /* Match on child triggers' tgparentid, not their name */
1818 lockmode);
1820 }
1821 }
1825 }
1837 /*
1838 * If we changed anything, broadcast a SI inval message to force each
1839 * backend (including our own!) to rebuild relation's relcache entry.
1840 * Otherwise they will fail to apply the change promptly.
1841 */
1844 }
1847 /*
1848 * Build trigger data to attach to the given relcache entry.
1849 *
1850 * Note that trigger data attached to a relcache entry must be stored in
1851 * CacheMemoryContext to ensure it survives as long as the relcache entry.
1852 * But we should be running in a less long-lived working context. To avoid
1853 * leaking cache memory if this routine fails partway through, we build a
1854 * temporary TriggerDesc in working memory and then copy the completed
1855 * structure into cache memory.
1856 */
1857 void
1859 {
1864 Relation tgrel;
1865 ScanKeyData skey;
1866 SysScanDesc tgscan;
1867 HeapTuple htup;
1868 MemoryContext oldContext;
1871 /*
1872 * Allocate a working array to hold the triggers (the array is extended if
1873 * necessary)
1874 */
1879 /*
1880 * Note: since we scan the triggers using TriggerRelidNameIndexId, we will
1881 * be reading the triggers in name order, except possibly during
1882 * emergency-recovery operations (ie, IgnoreSystemIndexes). This in turn
1883 * ensures that triggers will be fired in name order.
1884 */
1886 Anum_pg_trigger_tgrelid,
1895 {
1898 Datum datum;
1902 {
1905 }
1922 /* tgattr is first var-width field, so OK to access directly */
1925 {
1929 }
1930 else
1933 {
1938 Anum_pg_trigger_tgargs,
1946 {
1949 }
1950 }
1951 else
1959 else
1967 else
1974 else
1977 numtrigs++;
1978 }
1983 /* There might not be any triggers */
1985 {
1988 }
1990 /* Build trigdesc */
1997 /* Copy completed trigdesc into cache storage */
2002 /* Release working memory */
2004 }
2006 /*
2007 * Update the TriggerDesc's hint flags to include the specified trigger
2008 */
2009 static void
2011 {
2059 /* there are no row-level truncate triggers */
2079 }
2081 /*
2082 * Copy a TriggerDesc data structure.
2083 *
2084 * The copy is allocated in the current memory context.
2085 */
2086 TriggerDesc *
2088 {
2105 {
2108 {
2115 }
2117 {
2119 int16 j;
2125 }
2132 trigger++;
2133 }
2136 }
2138 /*
2139 * Free a TriggerDesc data structure.
2140 */
2141 void
2143 {
2152 {
2157 {
2161 }
2168 trigger++;
2169 }
2172 }
2174 /*
2175 * Compare two TriggerDesc structures for logical equality.
2176 */
2177 #ifdef NOT_USED
2178 bool
2180 {
2182 j;
2184 /*
2185 * We need not examine the hint flags, just the trigger array itself; if
2186 * we have the same triggers with the same types, the flags should match.
2187 *
2188 * As of 7.3 we assume trigger set ordering is significant in the
2189 * comparison; so we just compare corresponding slots of the two sets.
2190 *
2191 * Note: comparing the stringToNode forms of the WHEN clauses means that
2192 * parse column locations will affect the result. This is okay as long as
2193 * this function is only used for detecting exact equality, as for example
2194 * in checking for staleness of a cache entry.
2195 */
2197 {
2203 {
2260 }
2261 }
2265 }
2268 /*
2269 * Check if there is a row-level trigger with transition tables that prevents
2270 * a table from becoming an inheritance child or partition. Return the name
2271 * of the first such incompatible trigger, or NULL if there is none.
2272 */
2275 {
2277 {
2281 {
2286 }
2287 }
2290 }
2292 /*
2293 * Call a trigger function.
2294 *
2295 * trigdata: trigger descriptor.
2296 * tgindx: trigger's index in finfo and instr arrays.
2297 * finfo: array of cached trigger function call information.
2298 * instr: optional array of EXPLAIN ANALYZE instrumentation state.
2299 * per_tuple_context: memory context to execute the function in.
2300 *
2301 * Returns the tuple (or NULL) as returned by the function.
2302 */
2303 static HeapTuple
2308 MemoryContext per_tuple_context)
2309 {
2311 PgStat_FunctionCallUsage fcusage;
2312 Datum result;
2313 MemoryContext oldContext;
2315 /*
2316 * Protect against code paths that may fail to initialize transition table
2317 * info.
2318 */
2329 /*
2330 * We cache fmgr lookup info, to avoid making the lookup again on each
2331 * call.
2332 */
2338 /*
2339 * If doing EXPLAIN ANALYZE, start charging time to this trigger.
2340 */
2344 /*
2345 * Do the function evaluation in the per-tuple memory context, so that
2346 * leaked memory will be reclaimed once per tuple. Note in particular that
2347 * any new tuple created by the trigger function will live till the end of
2348 * the tuple cycle.
2349 */
2352 /*
2353 * Call the function, passing no arguments but setting a context.
2354 */
2360 MyTriggerDepth++;
2362 {
2364 }
2366 {
2367 MyTriggerDepth--;
2368 }
2375 /*
2376 * Trigger protocol allows function to return a null pointer, but NOT to
2377 * set the isnull result flag.
2378 */
2385 /*
2386 * If doing EXPLAIN ANALYZE, stop charging time to this trigger, and count
2387 * one "tuple returned" (really the number of firings).
2388 */
2393 }
2395 void
2397 {
2409 /* no-op if we already fired BS triggers in this context */
2411 CMD_INSERT))
2416 TRIGGER_EVENT_BEFORE;
2419 {
2421 HeapTuple newtuple;
2424 TRIGGER_TYPE_STATEMENT,
2425 TRIGGER_TYPE_BEFORE,
2426 TRIGGER_TYPE_INSERT))
2434 i,
2443 }
2444 }
2446 void
2449 {
2454 TRIGGER_EVENT_INSERT,
2457 }
2459 bool
2462 {
2471 TRIGGER_EVENT_ROW |
2472 TRIGGER_EVENT_BEFORE;
2475 {
2477 HeapTuple oldtuple;
2480 TRIGGER_TYPE_ROW,
2481 TRIGGER_TYPE_BEFORE,
2482 TRIGGER_TYPE_INSERT))
2495 i,
2500 {
2504 }
2506 {
2509 /*
2510 * After a tuple in a partition goes through a trigger, the user
2511 * could have changed the partition key enough that the tuple no
2512 * longer fits the partition. Verify that.
2513 */
2518 errmsg("moving row to another partition during a BEFORE FOR EACH ROW trigger is not supported"),
2527 /* signal tuple should be re-fetched if used */
2529 }
2530 }
2533 }
2535 void
2539 {
2545 TRIGGER_EVENT_INSERT,
2548 transition_capture,
2550 }
2552 bool
2555 {
2564 TRIGGER_EVENT_ROW |
2565 TRIGGER_EVENT_INSTEAD;
2568 {
2570 HeapTuple oldtuple;
2573 TRIGGER_TYPE_ROW,
2574 TRIGGER_TYPE_INSTEAD,
2575 TRIGGER_TYPE_INSERT))
2588 i,
2593 {
2597 }
2599 {
2605 /* signal tuple should be re-fetched if used */
2607 }
2608 }
2611 }
2613 void
2615 {
2627 /* no-op if we already fired BS triggers in this context */
2629 CMD_DELETE))
2634 TRIGGER_EVENT_BEFORE;
2637 {
2639 HeapTuple newtuple;
2642 TRIGGER_TYPE_STATEMENT,
2643 TRIGGER_TYPE_BEFORE,
2644 TRIGGER_TYPE_DELETE))
2652 i,
2661 }
2662 }
2664 void
2667 {
2672 TRIGGER_EVENT_DELETE,
2675 }
2677 /*
2678 * Execute BEFORE ROW DELETE triggers.
2679 *
2680 * True indicates caller can proceed with the delete. False indicates caller
2681 * need to suppress the delete and additionally if requested, we need to pass
2682 * back the concurrently updated tuple if any.
2683 */
2684 bool
2687 ItemPointer tupleid,
2688 HeapTuple fdw_trigtuple,
2692 {
2697 HeapTuple trigtuple;
2703 {
2711 /*
2712 * If the tuple was concurrently updated and the caller of this
2713 * function requested for the updated tuple, skip the trigger
2714 * execution.
2715 */
2717 {
2720 }
2723 }
2724 else
2725 {
2728 }
2732 TRIGGER_EVENT_ROW |
2733 TRIGGER_EVENT_BEFORE;
2736 {
2737 HeapTuple newtuple;
2741 TRIGGER_TYPE_ROW,
2742 TRIGGER_TYPE_BEFORE,
2743 TRIGGER_TYPE_DELETE))
2753 i,
2758 {
2761 }
2764 }
2769 }
2771 /*
2772 * Note: is_crosspart_update must be true if the DELETE is being performed
2773 * as part of a cross-partition update.
2774 */
2775 void
2778 ItemPointer tupleid,
2779 HeapTuple fdw_trigtuple,
2782 {
2787 {
2793 NULL,
2794 relinfo,
2795 tupleid,
2796 LockTupleExclusive,
2797 slot,
2798 NULL,
2799 NULL,
2800 NULL);
2801 else
2805 TRIGGER_EVENT_DELETE,
2807 transition_capture,
2808 is_crosspart_update);
2809 }
2810 }
2812 bool
2814 HeapTuple trigtuple)
2815 {
2823 TRIGGER_EVENT_ROW |
2824 TRIGGER_EVENT_INSTEAD;
2830 {
2831 HeapTuple rettuple;
2835 TRIGGER_TYPE_ROW,
2836 TRIGGER_TYPE_INSTEAD,
2837 TRIGGER_TYPE_DELETE))
2847 i,
2855 }
2857 }
2859 void
2861 {
2874 /* no-op if we already fired BS triggers in this context */
2876 CMD_UPDATE))
2879 /* statement-level triggers operate on the parent table */
2886 TRIGGER_EVENT_BEFORE;
2890 {
2892 HeapTuple newtuple;
2895 TRIGGER_TYPE_STATEMENT,
2896 TRIGGER_TYPE_BEFORE,
2897 TRIGGER_TYPE_UPDATE))
2905 i,
2914 }
2915 }
2917 void
2920 {
2923 /* statement-level triggers operate on the parent table */
2928 TRIGGER_EVENT_UPDATE,
2931 transition_capture,
2933 }
2935 bool
2938 ItemPointer tupleid,
2939 HeapTuple fdw_trigtuple,
2943 {
2947 HeapTuple trigtuple;
2953 LockTupleMode lockmode;
2955 /* Determine lock mode to use */
2960 {
2963 /* get a copy of the on-disk tuple we are planning to update */
2969 /*
2970 * In READ COMMITTED isolation level it's possible that target tuple
2971 * was changed due to concurrent update. In that case we have a raw
2972 * subplan output tuple in epqslot_candidate, and need to form a new
2973 * insertable tuple using ExecGetUpdateNewTuple to replace the one we
2974 * received in newslot. Neither we nor our callers have any further
2975 * interest in the passed-in tuple, so it's okay to overwrite newslot
2976 * with the newer data.
2977 */
2979 {
2983 oldslot);
2985 /*
2986 * Typically, the caller's newslot was also generated by
2987 * ExecGetUpdateNewTuple, so that epqslot_clean will be the same
2988 * slot and copying is not needed. But do the right thing if it
2989 * isn't.
2990 */
2994 /*
2995 * At this point newslot contains a virtual tuple that may
2996 * reference some fields of oldslot's tuple in some disk buffer.
2997 * If that tuple is in a different page than the original target
2998 * tuple, then our only pin on that buffer is oldslot's, and we're
2999 * about to release it. Hence we'd better materialize newslot to
3000 * ensure it doesn't contain references into an unpinned buffer.
3001 * (We'd materialize it below anyway, but too late for safety.)
3002 */
3004 }
3006 /*
3007 * Here we convert oldslot to a materialized slot holding trigtuple.
3008 * Neither slot passed to the triggers will hold any buffer pin.
3009 */
3011 }
3012 else
3013 {
3014 /* Put the FDW-supplied tuple into oldslot to unify the cases */
3017 }
3021 TRIGGER_EVENT_ROW |
3022 TRIGGER_EVENT_BEFORE;
3027 {
3029 HeapTuple oldtuple;
3032 TRIGGER_TYPE_ROW,
3033 TRIGGER_TYPE_BEFORE,
3034 TRIGGER_TYPE_UPDATE))
3049 i,
3055 {
3061 }
3063 {
3066 /*
3067 * If the tuple returned by the trigger / being stored, is the old
3068 * row version, and the heap tuple passed to the trigger was
3069 * allocated locally, materialize the slot. Otherwise we might
3070 * free it while still referenced by the slot.
3071 */
3078 /* signal tuple should be re-fetched if used */
3080 }
3081 }
3086 }
3088 /*
3089 * Note: 'src_partinfo' and 'dst_partinfo', when non-NULL, refer to the source
3090 * and destination partitions, respectively, of a cross-partition update of
3091 * the root partitioned table mentioned in the query, given by 'relinfo'.
3092 * 'tupleid' in that case refers to the ctid of the "old" tuple in the source
3093 * partition, and 'newslot' contains the "new" tuple in the destination
3094 * partition. This interface allows to support the requirements of
3095 * ExecCrossPartitionUpdateForeignKey(); is_crosspart_update must be true in
3096 * that case.
3097 */
3098 void
3102 ItemPointer tupleid,
3103 HeapTuple fdw_trigtuple,
3108 {
3115 {
3116 /*
3117 * Note: if the UPDATE is converted into a DELETE+INSERT as part of
3118 * update-partition-key operation, then this function is also called
3119 * separately for DELETE and INSERT to capture transition table rows.
3120 * In such case, either old tuple or new tuple can be NULL.
3121 */
3133 NULL,
3134 tupsrc,
3135 tupleid,
3136 LockTupleExclusive,
3137 oldslot,
3138 NULL,
3139 NULL,
3140 NULL);
3143 else
3148 TRIGGER_EVENT_UPDATE,
3152 transition_capture,
3153 is_crosspart_update);
3154 }
3155 }
3157 bool
3160 {
3170 TRIGGER_EVENT_ROW |
3171 TRIGGER_EVENT_INSTEAD;
3177 {
3179 HeapTuple oldtuple;
3182 TRIGGER_TYPE_ROW,
3183 TRIGGER_TYPE_INSTEAD,
3184 TRIGGER_TYPE_UPDATE))
3200 i,
3205 {
3207 }
3209 {
3215 /* signal tuple should be re-fetched if used */
3217 }
3218 }
3221 }
3223 void
3225 {
3239 TRIGGER_EVENT_BEFORE;
3243 {
3245 HeapTuple newtuple;
3248 TRIGGER_TYPE_STATEMENT,
3249 TRIGGER_TYPE_BEFORE,
3250 TRIGGER_TYPE_TRUNCATE))
3258 i,
3267 }
3268 }
3270 void
3272 {
3278 TRIGGER_EVENT_TRUNCATE,
3281 }
3284 /*
3285 * Fetch tuple into "oldslot", dealing with locking and EPQ if necessary
3286 */
3287 static bool
3291 ItemPointer tid,
3292 LockTupleMode lockmode,
3297 {
3301 {
3302 TM_Result test;
3303 TM_FailureData tmfd;
3308 /* caller must pass an epqstate if EvalPlanQual is possible */
3311 /*
3312 * lock tuple for update
3313 */
3319 lockflags,
3322 /* Let the caller know about the status of this operation */
3329 {
3332 /*
3333 * The target tuple was already updated or deleted by the
3334 * current command, or by a later command in the current
3335 * transaction. We ignore the tuple in the former case, and
3336 * throw error in the latter case, for the same reasons
3337 * enumerated in ExecUpdate and ExecDelete in
3338 * nodeModifyTable.c.
3339 */
3343 errmsg("tuple to be updated was already modified by an operation triggered by the current command"),
3344 errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
3346 /* treat it as deleted; do not process */
3351 {
3352 /*
3353 * Recheck the tuple using EPQ. For MERGE, we leave this
3354 * to the caller (it must do additional rechecking, and
3355 * might end up executing a different action entirely).
3356 */
3358 {
3362 }
3365 relation,
3367 oldslot);
3369 /*
3370 * If PlanQual failed for updated tuple - we must not
3371 * process this tuple!
3372 */
3374 {
3377 }
3378 }
3394 /* tuple was deleted */
3404 }
3405 }
3406 else
3407 {
3408 /*
3409 * We expect the tuple to be present, thus very simple error handling
3410 * suffices.
3411 */
3413 oldslot))
3415 }
3418 }
3420 /*
3421 * Is trigger enabled to fire?
3422 */
3423 static bool
3428 {
3429 /* Check replication-role-dependent enable state */
3431 {
3435 }
3437 {
3441 }
3443 /*
3444 * Check for column-specific trigger (only possible for UPDATE, and in
3445 * fact we *must* ignore tgattr for other event types)
3446 */
3448 {
3454 {
3456 modifiedCols))
3457 {
3460 }
3461 }
3464 }
3466 /* Check for WHEN clause */
3468 {
3471 MemoryContext oldContext;
3476 /*
3477 * trigger is an element of relinfo->ri_TrigDesc->triggers[]; find the
3478 * matching element of relinfo->ri_TrigWhenExprs[]
3479 */
3483 /*
3484 * If first time through for this WHEN expression, build expression
3485 * nodetrees for it. Keep them in the per-query memory context so
3486 * they'll survive throughout the query.
3487 */
3489 {
3494 /* Change references to OLD and NEW to INNER_VAR and OUTER_VAR */
3497 /* ExecPrepareQual wants implicit-AND form */
3501 }
3503 /*
3504 * We will use the EState's per-tuple context for evaluating WHEN
3505 * expressions (creating it if it's not already there).
3506 */
3509 /*
3510 * Finally evaluate the expression, making the old and/or new tuples
3511 * available as INNER_VAR/OUTER_VAR respectively.
3512 */
3517 }
3520 }
3523 /* ----------
3524 * After-trigger stuff
3525 *
3526 * The AfterTriggersData struct holds data about pending AFTER trigger events
3527 * during the current transaction tree. (BEFORE triggers are fired
3528 * immediately so we don't need any persistent state about them.) The struct
3529 * and most of its subsidiary data are kept in TopTransactionContext; however
3530 * some data that can be discarded sooner appears in the CurTransactionContext
3531 * of the relevant subtransaction. Also, the individual event records are
3532 * kept in a separate sub-context of TopTransactionContext. This is done
3533 * mainly so that it's easy to tell from a memory context dump how much space
3534 * is being eaten by trigger events.
3535 *
3536 * Because the list of pending events can grow large, we go to some
3537 * considerable effort to minimize per-event memory consumption. The event
3538 * records are grouped into chunks and common data for similar events in the
3539 * same chunk is only stored once.
3540 *
3541 * XXX We need to be able to save the per-event data in a file if it grows too
3542 * large.
3543 * ----------
3544 */
3546 /* Per-trigger SET CONSTRAINT status */
3548 {
3549 Oid sct_tgoid;
3555 /*
3556 * SET CONSTRAINT intra-transaction status.
3557 *
3558 * We make this a single palloc'd object so it can be copied and freed easily.
3559 *
3560 * all_isset and all_isdeferred are used to keep track
3561 * of SET CONSTRAINTS ALL {DEFERRED, IMMEDIATE}.
3562 *
3563 * trigstates[] stores per-trigger tgisdeferred settings.
3564 */
3566 {
3577 /*
3578 * Per-trigger-event data
3579 *
3580 * The actual per-event data, AfterTriggerEventData, includes DONE/IN_PROGRESS
3581 * status bits, up to two tuple CTIDs, and optionally two OIDs of partitions.
3582 * Each event record also has an associated AfterTriggerSharedData that is
3583 * shared across all instances of similar events within a "chunk".
3584 *
3585 * For row-level triggers, we arrange not to waste storage on unneeded ctid
3586 * fields. Updates of regular tables use two; inserts and deletes of regular
3587 * tables use one; foreign tables always use zero and save the tuple(s) to a
3588 * tuplestore. AFTER_TRIGGER_FDW_FETCH directs AfterTriggerExecute() to
3589 * retrieve a fresh tuple or pair of tuples from that tuplestore, while
3590 * AFTER_TRIGGER_FDW_REUSE directs it to use the most-recently-retrieved
3591 * tuple(s). This permits storing tuples once regardless of the number of
3592 * row-level triggers on a foreign table.
3593 *
3594 * When updates on partitioned tables cause rows to move between partitions,
3595 * the OIDs of both partitions are stored too, so that the tuples can be
3596 * fetched; such entries are marked AFTER_TRIGGER_CP_UPDATE (for "cross-
3597 * partition update").
3598 *
3599 * Note that we need triggers on foreign tables to be fired in exactly the
3600 * order they were queued, so that the tuples come out of the tuplestore in
3601 * the right order. To ensure that, we forbid deferrable (constraint)
3602 * triggers on foreign tables. This also ensures that such triggers do not
3603 * get deferred into outer trigger query levels, meaning that it's okay to
3604 * destroy the tuplestore at the end of the query level.
3605 *
3606 * Statement-level triggers always bear AFTER_TRIGGER_1CTID, though they
3607 * require no ctid field. We lack the flag bit space to neatly represent that
3608 * distinct case, and it seems unlikely to be worth much trouble.
3609 *
3610 * Note: ats_firing_id is initially zero and is set to something else when
3611 * AFTER_TRIGGER_IN_PROGRESS is set. It indicates which trigger firing
3612 * cycle the trigger will be fired in (or was fired in, if DONE is set).
3613 * Although this is mutable state, we can keep it in AfterTriggerSharedData
3614 * because all instances of the same type of event in a given event list will
3615 * be fired at the same time, if they were queued between the same firing
3616 * cycles. So we need only ensure that ats_firing_id is zero when attaching
3617 * a new event to an existing AfterTriggerSharedData record.
3618 */
3622 #define AFTER_TRIGGER_DONE 0x80000000
3623 #define AFTER_TRIGGER_IN_PROGRESS 0x40000000
3624 /* bits describing the size and tuple sources of this event */
3625 #define AFTER_TRIGGER_FDW_REUSE 0x00000000
3626 #define AFTER_TRIGGER_FDW_FETCH 0x20000000
3627 #define AFTER_TRIGGER_1CTID 0x10000000
3628 #define AFTER_TRIGGER_2CTID 0x30000000
3629 #define AFTER_TRIGGER_CP_UPDATE 0x08000000
3630 #define AFTER_TRIGGER_TUP_BITS 0x38000000
3634 {
3646 {
3651 /*
3652 * During a cross-partition update of a partitioned table, we also store
3653 * the OIDs of source and destination partitions that are needed to fetch
3654 * the old (ctid1) and the new tuple (ctid2) from, respectively.
3655 */
3656 Oid ate_src_part;
3657 Oid ate_dst_part;
3660 /* AfterTriggerEventData, minus ate_src_part, ate_dst_part */
3662 {
3663 TriggerFlags ate_flags;
3664 ItemPointerData ate_ctid1;
3665 ItemPointerData ate_ctid2;
3668 /* AfterTriggerEventData, minus ate_*_part and ate_ctid2 */
3670 {
3675 /* AfterTriggerEventData, minus ate_*_part, ate_ctid1 and ate_ctid2 */
3677 {
3681 #define SizeofTriggerEvent(evt) \
3682 (((evt)->ate_flags & AFTER_TRIGGER_TUP_BITS) == AFTER_TRIGGER_CP_UPDATE ? \
3683 sizeof(AfterTriggerEventData) : \
3684 (((evt)->ate_flags & AFTER_TRIGGER_TUP_BITS) == AFTER_TRIGGER_2CTID ? \
3685 sizeof(AfterTriggerEventDataNoOids) : \
3686 (((evt)->ate_flags & AFTER_TRIGGER_TUP_BITS) == AFTER_TRIGGER_1CTID ? \
3687 sizeof(AfterTriggerEventDataOneCtid) : \
3688 sizeof(AfterTriggerEventDataZeroCtids))))
3690 #define GetTriggerSharedData(evt) \
3691 ((AfterTriggerShared) ((char *) (evt) + ((evt)->ate_flags & AFTER_TRIGGER_OFFSET)))
3693 /*
3694 * To avoid palloc overhead, we keep trigger events in arrays in successively-
3695 * larger chunks (a slightly more sophisticated version of an expansible
3696 * array). The space between CHUNK_DATA_START and freeptr is occupied by
3697 * AfterTriggerEventData records; the space between endfree and endptr is
3698 * occupied by AfterTriggerSharedData records.
3699 */
3701 {
3706 /* event data follows here */
3709 #define CHUNK_DATA_START(cptr) ((char *) (cptr) + MAXALIGN(sizeof(AfterTriggerEventChunk)))
3711 /* A list of events */
3713 {
3719 /* Macros to help in iterating over a list of events */
3720 #define for_each_chunk(cptr, evtlist) \
3721 for (cptr = (evtlist).head; cptr != NULL; cptr = cptr->next)
3722 #define for_each_event(eptr, cptr) \
3723 for (eptr = (AfterTriggerEvent) CHUNK_DATA_START(cptr); \
3724 (char *) eptr < (cptr)->freeptr; \
3725 eptr = (AfterTriggerEvent) (((char *) eptr) + SizeofTriggerEvent(eptr)))
3726 /* Use this if no special per-chunk processing is needed */
3727 #define for_each_event_chunk(eptr, cptr, evtlist) \
3728 for_each_chunk(cptr, evtlist) for_each_event(eptr, cptr)
3730 /* Macros for iterating from a start point that might not be list start */
3731 #define for_each_chunk_from(cptr) \
3732 for (; cptr != NULL; cptr = cptr->next)
3733 #define for_each_event_from(eptr, cptr) \
3734 for (; \
3735 (char *) eptr < (cptr)->freeptr; \
3736 eptr = (AfterTriggerEvent) (((char *) eptr) + SizeofTriggerEvent(eptr)))
3739 /*
3740 * All per-transaction data for the AFTER TRIGGERS module.
3741 *
3742 * AfterTriggersData has the following fields:
3743 *
3744 * firing_counter is incremented for each call of afterTriggerInvokeEvents.
3745 * We mark firable events with the current firing cycle's ID so that we can
3746 * tell which ones to work on. This ensures sane behavior if a trigger
3747 * function chooses to do SET CONSTRAINTS: the inner SET CONSTRAINTS will
3748 * only fire those events that weren't already scheduled for firing.
3749 *
3750 * state keeps track of the transaction-local effects of SET CONSTRAINTS.
3751 * This is saved and restored across failed subtransactions.
3752 *
3753 * events is the current list of deferred events. This is global across
3754 * all subtransactions of the current transaction. In a subtransaction
3755 * abort, we know that the events added by the subtransaction are at the
3756 * end of the list, so it is relatively easy to discard them. The event
3757 * list chunks themselves are stored in event_cxt.
3758 *
3759 * query_depth is the current depth of nested AfterTriggerBeginQuery calls
3760 * (-1 when the stack is empty).
3761 *
3762 * query_stack[query_depth] is the per-query-level data, including these fields:
3763 *
3764 * events is a list of AFTER trigger events queued by the current query.
3765 * None of these are valid until the matching AfterTriggerEndQuery call
3766 * occurs. At that point we fire immediate-mode triggers, and append any
3767 * deferred events to the main events list.
3768 *
3769 * fdw_tuplestore is a tuplestore containing the foreign-table tuples
3770 * needed by events queued by the current query. (Note: we use just one
3771 * tuplestore even though more than one foreign table might be involved.
3772 * This is okay because tuplestores don't really care what's in the tuples
3773 * they store; but it's possible that someday it'd break.)
3774 *
3775 * tables is a List of AfterTriggersTableData structs for target tables
3776 * of the current query (see below).
3777 *
3778 * maxquerydepth is just the allocated length of query_stack.
3779 *
3780 * trans_stack holds per-subtransaction data, including these fields:
3781 *
3782 * state is NULL or a pointer to a saved copy of the SET CONSTRAINTS
3783 * state data. Each subtransaction level that modifies that state first
3784 * saves a copy, which we use to restore the state if we abort.
3785 *
3786 * events is a copy of the events head/tail pointers,
3787 * which we use to restore those values during subtransaction abort.
3788 *
3789 * query_depth is the subtransaction-start-time value of query_depth,
3790 * which we similarly use to clean up at subtransaction abort.
3791 *
3792 * firing_counter is the subtransaction-start-time value of firing_counter.
3793 * We use this to recognize which deferred triggers were fired (or marked
3794 * for firing) within an aborted subtransaction.
3795 *
3796 * We use GetCurrentTransactionNestLevel() to determine the correct array
3797 * index in trans_stack. maxtransdepth is the number of allocated entries in
3798 * trans_stack. (By not keeping our own stack pointer, we can avoid trouble
3799 * in cases where errors during subxact abort cause multiple invocations
3800 * of AfterTriggerEndSubXact() at the same nesting depth.)
3801 *
3802 * We create an AfterTriggersTableData struct for each target table of the
3803 * current query, and each operation mode (INSERT/UPDATE/DELETE), that has
3804 * either transition tables or statement-level triggers. This is used to
3805 * hold the relevant transition tables, as well as info tracking whether
3806 * we already queued the statement triggers. (We use that info to prevent
3807 * firing the same statement triggers more than once per statement, or really
3808 * once per transition table set.) These structs, along with the transition
3809 * table tuplestores, live in the (sub)transaction's CurTransactionContext.
3810 * That's sufficient lifespan because we don't allow transition tables to be
3811 * used by deferrable triggers, so they only need to survive until
3812 * AfterTriggerEndQuery.
3813 */
3819 {
3825 /* per-query-level data: */
3830 /* per-subtransaction-level data: */
3835 struct AfterTriggersQueryData
3836 {
3840 };
3842 struct AfterTriggersTransData
3843 {
3844 /* these fields are just for resetting at subtrans abort: */
3849 };
3851 struct AfterTriggersTableData
3852 {
3853 /* relid + cmdType form the lookup key for these structs: */
3861 /*
3862 * We maintain separate transition tables for UPDATE/INSERT/DELETE since
3863 * MERGE can run all three actions in a single statement. Note that UPDATE
3864 * needs both old and new transition tables whereas INSERT needs only new,
3865 * and DELETE needs only old.
3866 */
3868 /* "old" transition table for UPDATE, if any */
3870 /* "new" transition table for UPDATE, if any */
3872 /* "old" transition table for DELETE, if any */
3874 /* "new" transition table for INSERT, if any */
3878 };
3883 AfterTriggerEvent event,
3890 MemoryContext per_tuple_context,
3894 CmdType cmdType);
3896 TupleDesc tupdesc);
3915 /*
3916 * Get the FDW tuplestore for the current trigger query level, creating it
3917 * if necessary.
3918 */
3921 {
3926 {
3927 MemoryContext oldcxt;
3928 ResourceOwner saveResourceOwner;
3930 /*
3931 * Make the tuplestore valid until end of subtransaction. We really
3932 * only need it until AfterTriggerEndQuery().
3933 */
3944 }
3947 }
3949 /* ----------
3950 * afterTriggerCheckState()
3951 *
3952 * Returns true if the trigger event is actually in state DEFERRED.
3953 * ----------
3954 */
3955 static bool
3957 {
3962 /*
3963 * For not-deferrable triggers (i.e. normal AFTER ROW triggers and
3964 * constraints declared NOT DEFERRABLE), the state is always false.
3965 */
3969 /*
3970 * If constraint state exists, SET CONSTRAINTS might have been executed
3971 * either for this trigger or for all triggers.
3972 */
3974 {
3975 /* Check for SET CONSTRAINTS for this specific trigger. */
3977 {
3980 }
3982 /* Check for SET CONSTRAINTS ALL. */
3985 }
3987 /*
3988 * Otherwise return the default state for the trigger.
3989 */
3991 }
3993 /* ----------
3994 * afterTriggerCopyBitmap()
3995 *
3996 * Copy bitmap into AfterTriggerEvents memory context, which is where the after
3997 * trigger events are kept.
3998 * ----------
3999 */
4002 {
4004 MemoryContext oldcxt;
4009 /* Create event context if we didn't already */
4014 ALLOCSET_DEFAULT_SIZES);
4023 }
4025 /* ----------
4026 * afterTriggerAddEvent()
4027 *
4028 * Add a new trigger event to the specified queue.
4029 * The passed-in event data is copied.
4030 * ----------
4031 */
4032 static void
4035 {
4039 AfterTriggerShared newshared;
4040 AfterTriggerEvent newevent;
4042 /*
4043 * If empty list or not enough room in the tail chunk, make a new chunk.
4044 * We assume here that a new shared record will always be needed.
4045 */
4049 {
4050 Size chunksize;
4052 /* Create event context if we didn't already */
4057 ALLOCSET_DEFAULT_SIZES);
4059 /*
4060 * Chunk size starts at 1KB and is allowed to increase up to 1MB.
4061 * These numbers are fairly arbitrary, though there is a hard limit at
4062 * AFTER_TRIGGER_OFFSET; else we couldn't link event records to their
4063 * shared records using the available space in ate_flags. Another
4064 * constraint is that if the chunk size gets too huge, the search loop
4065 * below would get slow given a (not too common) usage pattern with
4066 * many distinct event types in a chunk. Therefore, we double the
4067 * preceding chunk size only if there weren't too many shared records
4068 * in the preceding chunk; otherwise we halve it. This gives us some
4069 * ability to adapt to the actual usage pattern of the current query
4070 * while still having large chunk sizes in typical usage. All chunk
4071 * sizes used should be MAXALIGN multiples, to ensure that the shared
4072 * records will be aligned safely.
4073 */
4074 #define MIN_CHUNK_SIZE 1024
4075 #define MAX_CHUNK_SIZE (1024*1024)
4077 #if MAX_CHUNK_SIZE > (AFTER_TRIGGER_OFFSET+1)
4078 #error MAX_CHUNK_SIZE must not exceed AFTER_TRIGGER_OFFSET
4079 #endif
4083 else
4084 {
4085 /* preceding chunk size... */
4087 /* check number of shared records in preceding chunk */
4091 else
4094 }
4102 {
4105 }
4106 else
4109 /* events->tailfree is now out of sync, but we'll fix it below */
4110 }
4112 /*
4113 * Try to locate a matching shared-data record already in the chunk. If
4114 * none, make a new one.
4115 */
4118 newshared--)
4119 {
4126 }
4128 {
4132 }
4134 /* Insert the data */
4137 /* ... and link the new event to its shared record */
4143 }
4145 /* ----------
4146 * afterTriggerFreeEventList()
4147 *
4148 * Free all the event storage in the given list.
4149 * ----------
4150 */
4151 static void
4153 {
4157 {
4160 }
4163 }
4165 /* ----------
4166 * afterTriggerRestoreEventList()
4167 *
4168 * Restore an event list to its prior length, removing all the events
4169 * added since it had the value old_events.
4170 * ----------
4171 */
4172 static void
4175 {
4180 {
4181 /* restoring to a completely empty state, so free everything */
4183 }
4184 else
4185 {
4187 /* free any chunks after the last one we want to keep */
4189 {
4192 }
4193 /* and clean up the tail chunk to be the right length */
4197 /*
4198 * We don't make any effort to remove now-unused shared data records.
4199 * They might still be useful, anyway.
4200 */
4201 }
4202 }
4204 /* ----------
4205 * afterTriggerDeleteHeadEventChunk()
4206 *
4207 * Remove the first chunk of events from the query level's event list.
4208 * Keep any event list pointers elsewhere in the query level's data
4209 * structures in sync.
4210 * ----------
4211 */
4212 static void
4214 {
4220 /*
4221 * First, update any pointers in the per-table data, so that they won't be
4222 * dangling. Resetting obsoleted pointers to NULL will make
4223 * cancel_prior_stmt_triggers start from the list head, which is fine.
4224 */
4226 {
4231 {
4235 }
4236 }
4238 /* Now we can flush the head chunk */
4241 }
4244 /* ----------
4245 * AfterTriggerExecute()
4246 *
4247 * Fetch the required tuples back from the heap and fire one
4248 * single trigger function.
4249 *
4250 * Frequently, this will be fired many times in a row for triggers of
4251 * a single relation. Therefore, we cache the open relation and provide
4252 * fmgr lookup cache space at the caller level. (For triggers fired at
4253 * the end of a query, we can even piggyback on the executor's state.)
4254 *
4255 * When fired for a cross-partition update of a partitioned table, the old
4256 * tuple is fetched using 'src_relInfo' (the source leaf partition) and
4257 * the new tuple using 'dst_relInfo' (the destination leaf partition), though
4258 * both are converted into the root partitioned table's format before passing
4259 * to the trigger function.
4260 *
4261 * event: event currently being fired.
4262 * relInfo: result relation for event.
4263 * src_relInfo: source partition of a cross-partition update
4264 * dst_relInfo: its destination partition
4265 * trigdesc: working copy of rel's trigger info.
4266 * finfo: array of fmgr lookup cache entries (one per trigger in trigdesc).
4267 * instr: array of EXPLAIN ANALYZE instrumentation nodes (one per trigger),
4268 * or NULL if no instrumentation is wanted.
4269 * per_tuple_context: memory context to call trigger function in.
4270 * trig_tuple_slot1: scratch slot for tg_trigtuple (foreign tables only)
4271 * trig_tuple_slot2: scratch slot for tg_newtuple (foreign tables only)
4272 * ----------
4273 */
4274 static void
4276 AfterTriggerEvent event,
4282 MemoryContext per_tuple_context,
4285 {
4292 HeapTuple rettuple;
4297 /*
4298 * Locate trigger in trigdesc. It might not be present, and in fact the
4299 * trigdesc could be NULL, if the trigger was dropped since the event was
4300 * queued. In that case, silently do nothing.
4301 */
4305 {
4307 {
4310 }
4311 }
4315 /*
4316 * If doing EXPLAIN ANALYZE, start charging time to this trigger. We want
4317 * to include time spent re-fetching tuples in the trigger cost.
4318 */
4322 /*
4323 * Fetch the required tuple(s).
4324 */
4326 {
4328 {
4332 trig_tuple_slot1))
4336 TRIGGER_EVENT_UPDATE &&
4338 trig_tuple_slot2))
4340 }
4341 /* fall through */
4344 /*
4345 * Store tuple in the slot so that tg_trigtuple does not reference
4346 * tuplestore memory. (It is formally possible for the trigger
4347 * function to queue trigger events that add to the same
4348 * tuplestore, which can push other tuples out of memory.) The
4349 * distinction is academic, because we start with a minimal tuple
4350 * that is stored as a heap tuple, constructed in different memory
4351 * context, in the slot anyway.
4352 */
4358 TRIGGER_EVENT_UPDATE)
4359 {
4363 }
4364 else
4365 {
4367 }
4372 {
4374 src_relInfo);
4378 SnapshotAny,
4379 src_slot))
4382 /*
4383 * Store the tuple fetched from the source partition into the
4384 * target (root partitioned) table slot, converting if needed.
4385 */
4387 {
4392 {
4394 src_slot,
4396 }
4397 else
4399 }
4400 else
4404 }
4405 else
4406 {
4408 }
4410 /* don't touch ctid2 if not there */
4414 {
4416 dst_relInfo);
4420 SnapshotAny,
4421 dst_slot))
4424 /*
4425 * Store the tuple fetched from the destination partition into
4426 * the target (root partitioned) table slot, converting if
4427 * needed.
4428 */
4430 {
4435 {
4437 dst_slot,
4439 }
4440 else
4442 }
4443 else
4447 }
4448 else
4449 {
4451 }
4452 }
4454 /*
4455 * Set up the tuplestore information to let the trigger have access to
4456 * transition tables. When we first make a transition table available to
4457 * a trigger, mark it "closed" so that it cannot change anymore. If any
4458 * additional events of the same type get queued in the current trigger
4459 * query level, they'll go into new transition tables.
4460 */
4463 {
4465 {
4468 else
4471 }
4474 {
4477 else
4480 }
4481 }
4483 /*
4484 * Setup the remaining trigger information
4485 */
4495 /*
4496 * Call the trigger and throw away any possibly returned updated tuple.
4497 * (Don't let ExecCallTriggerFunc measure EXPLAIN time.)
4498 */
4500 tgindx,
4501 finfo,
4502 NULL,
4503 per_tuple_context);
4509 /*
4510 * Release resources
4511 */
4517 /* don't clear slots' contents if foreign table */
4519 {
4524 }
4526 /*
4527 * If doing EXPLAIN ANALYZE, stop charging time to this trigger, and count
4528 * one "tuple returned" (really the number of firings).
4529 */
4532 }
4535 /*
4536 * afterTriggerMarkEvents()
4537 *
4538 * Scan the given event list for not yet invoked events. Mark the ones
4539 * that can be invoked now with the current firing ID.
4540 *
4541 * If move_list isn't NULL, events that are not to be invoked now are
4542 * transferred to move_list.
4543 *
4544 * When immediate_only is true, do not invoke currently-deferred triggers.
4545 * (This will be false only at main transaction exit.)
4546 *
4547 * Returns true if any invokable events were found.
4548 */
4549 static bool
4553 {
4556 AfterTriggerEvent event;
4560 {
4566 {
4567 /*
4568 * This trigger hasn't been called or scheduled yet. Check if we
4569 * should call it now.
4570 */
4572 {
4574 }
4575 else
4576 {
4577 /*
4578 * Mark it as to be fired in this firing cycle.
4579 */
4583 }
4584 }
4586 /*
4587 * If it's deferred, move it to move_list, if requested.
4588 */
4590 {
4592 /* add it to move_list */
4594 /* mark original copy "done" so we don't do it again */
4596 }
4597 }
4599 /*
4600 * We could allow deferred triggers if, before the end of the
4601 * security-restricted operation, we were to verify that a SET CONSTRAINTS
4602 * ... IMMEDIATE has fired all such triggers. For now, don't bother.
4603 */
4610 }
4612 /*
4613 * afterTriggerInvokeEvents()
4614 *
4615 * Scan the given event list for events that are marked as to be fired
4616 * in the current firing cycle, and fire them.
4617 *
4618 * If estate isn't NULL, we use its result relation info to avoid repeated
4619 * openings and closing of trigger target relations. If it is NULL, we
4620 * make one locally to cache the info in case there are multiple trigger
4621 * events per rel.
4622 *
4623 * When delete_ok is true, it's safe to delete fully-processed events.
4624 * (We are not very tense about that: we simply reset a chunk to be empty
4625 * if all its events got fired. The objective here is just to avoid useless
4626 * rescanning of events when a trigger queues new events during transaction
4627 * end, so it's not necessary to worry much about the case where only
4628 * some events are fired.)
4629 *
4630 * Returns true if no unfired events remain in the list (this allows us
4631 * to avoid repeating afterTriggerMarkEvents).
4632 */
4633 static bool
4635 CommandId firing_id,
4638 {
4641 MemoryContext per_tuple_context;
4651 /* Make a local EState if need be */
4653 {
4656 }
4658 /* Make a per-tuple memory context for trigger function calls */
4659 per_tuple_context =
4662 ALLOCSET_DEFAULT_SIZES);
4665 {
4666 AfterTriggerEvent event;
4670 {
4673 /*
4674 * Is it one for me to fire?
4675 */
4678 {
4682 /*
4683 * So let's fire it... but first, find the correct relation if
4684 * this is not the same relation as before.
4685 */
4687 {
4689 NULL);
4691 /* Catch calls with insufficient relcache refcounting */
4694 /* caution: trigdesc could be NULL here */
4698 {
4702 }
4704 {
4709 }
4710 }
4712 /*
4713 * Look up source and destination partition result rels of a
4714 * cross-partition update event.
4715 */
4717 AFTER_TRIGGER_CP_UPDATE)
4718 {
4723 rInfo);
4726 rInfo);
4727 }
4728 else
4731 /*
4732 * Fire it. Note that the AFTER_TRIGGER_IN_PROGRESS flag is
4733 * still set, so recursive examinations of the event list
4734 * won't try to re-fire it.
4735 */
4741 /*
4742 * Mark the event as done.
4743 */
4746 }
4748 {
4749 /* something remains to be done */
4751 }
4752 }
4754 /* Clear the chunk if delete_ok and nothing left of interest */
4756 {
4760 /*
4761 * If it's last chunk, must sync event list's tailfree too. Note
4762 * that delete_ok must NOT be passed as true if there could be
4763 * additional AfterTriggerEventList values pointing at this event
4764 * list, since we'd fail to fix their copies of tailfree.
4765 */
4768 }
4769 }
4771 {
4774 }
4776 /* Release working resources */
4780 {
4784 }
4787 }
4790 /*
4791 * GetAfterTriggersTableData
4792 *
4793 * Find or create an AfterTriggersTableData struct for the specified
4794 * trigger event (relation + operation type). Ignore existing structs
4795 * marked "closed"; we don't want to put any additional tuples into them,
4796 * nor change their stmt-triggers-fired state.
4797 *
4798 * Note: the AfterTriggersTableData list is allocated in the current
4799 * (sub)transaction's CurTransactionContext. This is OK because
4800 * we don't need it to live past AfterTriggerEndQuery.
4801 */
4804 {
4807 MemoryContext oldcxt;
4810 /* Caller should have ensured query_depth is OK. */
4816 {
4821 }
4833 }
4835 /*
4836 * Returns a TupleTableSlot suitable for holding the tuples to be put
4837 * into AfterTriggersTableData's transition table tuplestores.
4838 */
4841 TupleDesc tupdesc)
4842 {
4843 /* Create it if not already done. */
4845 {
4846 MemoryContext oldcxt;
4848 /*
4849 * We need this slot only until AfterTriggerEndQuery, but making it
4850 * last till end-of-subxact is good enough. It'll be freed by
4851 * AfterTriggerFreeQuery(). However, the passed-in tupdesc might have
4852 * a different lifespan, so we'd better make a copy of that.
4853 */
4858 }
4861 }
4863 /*
4864 * MakeTransitionCaptureState
4865 *
4866 * Make a TransitionCaptureState object for the given TriggerDesc, target
4867 * relation, and operation type. The TCS object holds all the state needed
4868 * to decide whether to capture tuples in transition tables.
4869 *
4870 * If there are no triggers in 'trigdesc' that request relevant transition
4871 * tables, then return NULL.
4872 *
4873 * The resulting object can be passed to the ExecAR* functions. When
4874 * dealing with child tables, the caller can set tcs_original_insert_tuple
4875 * to avoid having to reconstruct the original tuple in the root table's
4876 * format.
4877 *
4878 * Note that we copy the flags from a parent table into this struct (rather
4879 * than subsequently using the relation's TriggerDesc directly) so that we can
4880 * use it to control collection of transition tuples from child tables.
4881 *
4882 * Per SQL spec, all operations of the same kind (INSERT/UPDATE/DELETE)
4883 * on the same table during one query should share one transition table.
4884 * Therefore, the Tuplestores are owned by an AfterTriggersTableData struct
4885 * looked up using the table OID + CmdType, and are merely referenced by
4886 * the TransitionCaptureState objects we hand out to callers.
4887 */
4888 TransitionCaptureState *
4890 {
4893 need_new_upd,
4894 need_old_del,
4895 need_new_ins;
4897 MemoryContext oldcxt;
4898 ResourceOwner saveResourceOwner;
4903 /* Detect which table(s) we need. */
4905 {
4927 /* keep compiler quiet */
4930 }
4934 /* Check state, like AfterTriggerSaveEvent. */
4938 /* Be sure we have enough space to record events at this query depth. */
4942 /*
4943 * Find or create an AfterTriggersTableData struct to hold the
4944 * tuplestore(s). If there's a matching struct but it's marked closed,
4945 * ignore it; we need a newer one.
4946 *
4947 * Note: the AfterTriggersTableData list, as well as the tuplestores, are
4948 * allocated in the current (sub)transaction's CurTransactionContext, and
4949 * the tuplestores are managed by the (sub)transaction's resource owner.
4950 * This is sufficient lifespan because we do not allow triggers using
4951 * transition tables to be deferrable; they will be fired during
4952 * AfterTriggerEndQuery, after which it's okay to delete the data.
4953 */
4956 /* Now create required tuplestore(s), if we don't have them already. */
4973 /* Now build the TransitionCaptureState struct, in caller's context */
4982 }
4985 /* ----------
4986 * AfterTriggerBeginXact()
4987 *
4988 * Called at transaction start (either BEGIN or implicit for single
4989 * statement outside of transaction block).
4990 * ----------
4991 */
4992 void
4994 {
4995 /*
4996 * Initialize after-trigger state structure to empty
4997 */
5001 /*
5002 * Verify that there is no leftover state remaining. If these assertions
5003 * trip, it means that AfterTriggerEndXact wasn't called or didn't clean
5004 * up properly.
5005 */
5013 }
5016 /* ----------
5017 * AfterTriggerBeginQuery()
5018 *
5019 * Called just before we start processing a single query within a
5020 * transaction (or subtransaction). Most of the real work gets deferred
5021 * until somebody actually tries to queue a trigger event.
5022 * ----------
5023 */
5024 void
5026 {
5027 /* Increase the query stack depth */
5029 }
5032 /* ----------
5033 * AfterTriggerEndQuery()
5034 *
5035 * Called after one query has been completely processed. At this time
5036 * we invoke all AFTER IMMEDIATE trigger events queued by the query, and
5037 * transfer deferred trigger events to the global deferred-trigger list.
5038 *
5039 * Note that this must be called BEFORE closing down the executor
5040 * with ExecutorEnd, because we make use of the EState's info about
5041 * target relations. Normally it is called from ExecutorFinish.
5042 * ----------
5043 */
5044 void
5046 {
5049 /* Must be inside a query, too */
5052 /*
5053 * If we never even got as far as initializing the event stack, there
5054 * certainly won't be any events, so exit quickly.
5055 */
5057 {
5060 }
5062 /*
5063 * Process all immediate-mode triggers queued by the query, and move the
5064 * deferred ones to the main list of deferred events.
5065 *
5066 * Notice that we decide which ones will be fired, and put the deferred
5067 * ones on the main list, before anything is actually fired. This ensures
5068 * reasonably sane behavior if a trigger function does SET CONSTRAINTS ...
5069 * IMMEDIATE: all events we have decided to defer will be available for it
5070 * to fire.
5071 *
5072 * We loop in case a trigger queues more events at the same query level.
5073 * Ordinary trigger functions, including all PL/pgSQL trigger functions,
5074 * will instead fire any triggers in a dedicated query level. Foreign key
5075 * enforcement triggers do add to the current query level, thanks to their
5076 * passing fire_triggers = false to SPI_execute_snapshot(). Other
5077 * C-language triggers might do likewise.
5078 *
5079 * If we find no firable events, we don't have to increment
5080 * firing_counter.
5081 */
5085 {
5087 {
5094 /*
5095 * Firing a trigger could result in query_stack being repalloc'd,
5096 * so we must recalculate qs after each afterTriggerInvokeEvents
5097 * call. Furthermore, it's unsafe to pass delete_ok = true here,
5098 * because that could cause afterTriggerInvokeEvents to try to
5099 * access qs->events after the stack has been repalloc'd.
5100 */
5103 /*
5104 * We'll need to scan the events list again. To reduce the cost
5105 * of doing so, get rid of completely-fired chunks. We know that
5106 * all events were marked IN_PROGRESS or DONE at the conclusion of
5107 * afterTriggerMarkEvents, so any still-interesting events must
5108 * have been added after that, and so must be in the chunk that
5109 * was then the tail chunk, or in later chunks. So, zap all
5110 * chunks before oldtail. This is approximately the same set of
5111 * events we would have gotten rid of by passing delete_ok = true.
5112 */
5116 }
5117 else
5119 }
5121 /* Release query-level-local storage, including tuplestores if any */
5125 }
5128 /*
5129 * AfterTriggerFreeQuery
5130 * Release subsidiary storage for a trigger query level.
5131 * This includes closing down tuplestores.
5132 * Note: it's important for this to be safe if interrupted by an error
5133 * and then called again for the same query level.
5134 */
5135 static void
5137 {
5142 /* Drop the trigger events */
5145 /* Drop FDW tuplestore if any */
5151 /* Release per-table subsidiary storage */
5154 {
5174 {
5179 }
5180 }
5182 /*
5183 * Now free the AfterTriggersTableData structs and list cells. Reset list
5184 * pointer first; if list_free_deep somehow gets an error, better to leak
5185 * that storage than have an infinite loop.
5186 */
5189 }
5192 /* ----------
5193 * AfterTriggerFireDeferred()
5194 *
5195 * Called just before the current transaction is committed. At this
5196 * time we invoke all pending DEFERRED triggers.
5197 *
5198 * It is possible for other modules to queue additional deferred triggers
5199 * during pre-commit processing; therefore xact.c may have to call this
5200 * multiple times.
5201 * ----------
5202 */
5203 void
5205 {
5209 /* Must not be inside a query */
5212 /*
5213 * If there are any triggers to fire, make sure we have set a snapshot for
5214 * them to use. (Since PortalRunUtility doesn't set a snap for COMMIT, we
5215 * can't assume ActiveSnapshot is valid on entry.)
5216 */
5219 {
5222 }
5224 /*
5225 * Run all the remaining triggers. Loop until they are all gone, in case
5226 * some trigger queues more for us to do.
5227 */
5229 {
5234 }
5236 /*
5237 * We don't bother freeing the event list, since it will go away anyway
5238 * (and more efficiently than via pfree) in AfterTriggerEndXact.
5239 */
5243 }
5246 /* ----------
5247 * AfterTriggerEndXact()
5248 *
5249 * The current transaction is finishing.
5250 *
5251 * Any unfired triggers are canceled so we simply throw
5252 * away anything we know.
5253 *
5254 * Note: it is possible for this to be called repeatedly in case of
5255 * error during transaction abort; therefore, do not complain if
5256 * already closed down.
5257 * ----------
5258 */
5259 void
5261 {
5262 /*
5263 * Forget the pending-events list.
5264 *
5265 * Since all the info is in TopTransactionContext or children thereof, we
5266 * don't really need to do anything to reclaim memory. However, the
5267 * pending-events list could be large, and so it's useful to discard it as
5268 * soon as possible --- especially if we are aborting because we ran out
5269 * of memory for the list!
5270 */
5272 {
5278 }
5280 /*
5281 * Forget any subtransaction state as well. Since this can't be very
5282 * large, we let the eventual reset of TopTransactionContext free the
5283 * memory instead of doing it here.
5284 */
5289 /*
5290 * Forget the query stack and constraint-related state information. As
5291 * with the subtransaction state information, we don't bother freeing the
5292 * memory here.
5293 */
5298 /* No more afterTriggers manipulation until next transaction starts. */
5300 }
5302 /*
5303 * AfterTriggerBeginSubXact()
5304 *
5305 * Start a subtransaction.
5306 */
5307 void
5309 {
5312 /*
5313 * Allocate more space in the trans_stack if needed. (Note: because the
5314 * minimum nest level of a subtransaction is 2, we waste the first couple
5315 * entries of the array; not worth the notational effort to avoid it.)
5316 */
5318 {
5320 {
5321 /* Arbitrarily initialize for max of 8 subtransaction levels */
5326 }
5327 else
5328 {
5329 /* repalloc will keep the stack in the same context */
5336 }
5337 }
5339 /*
5340 * Push the current information into the stack. The SET CONSTRAINTS state
5341 * is not saved until/unless changed. Likewise, we don't make a
5342 * per-subtransaction event context until needed.
5343 */
5348 }
5350 /*
5351 * AfterTriggerEndSubXact()
5352 *
5353 * The current subtransaction is ending.
5354 */
5355 void
5357 {
5359 SetConstraintState state;
5360 AfterTriggerEvent event;
5362 CommandId subxact_firing_id;
5364 /*
5365 * Pop the prior state if needed.
5366 */
5368 {
5370 /* If we saved a prior state, we don't need it anymore */
5374 /* this avoids double pfree if error later: */
5378 }
5379 else
5380 {
5381 /*
5382 * Aborting. It is possible subxact start failed before calling
5383 * AfterTriggerBeginSubXact, in which case we mustn't risk touching
5384 * trans_stack levels that aren't there.
5385 */
5389 /*
5390 * Release query-level storage for queries being aborted, and restore
5391 * query_depth to its pre-subxact value. This assumes that a
5392 * subtransaction will not add events to query levels started in a
5393 * earlier transaction state.
5394 */
5396 {
5400 }
5404 /*
5405 * Restore the global deferred-event list to its former length,
5406 * discarding any events queued by the subxact.
5407 */
5411 /*
5412 * Restore the trigger state. If the saved state is NULL, then this
5413 * subxact didn't save it, so it doesn't need restoring.
5414 */
5417 {
5420 }
5421 /* this avoids double pfree if error later: */
5424 /*
5425 * Scan for any remaining deferred events that were marked DONE or IN
5426 * PROGRESS by this subxact or a child, and un-mark them. We can
5427 * recognize such events because they have a firing ID greater than or
5428 * equal to the firing_counter value we saved at subtransaction start.
5429 * (This essentially assumes that the current subxact includes all
5430 * subxacts started after it.)
5431 */
5434 {
5439 {
5443 }
5444 }
5445 }
5446 }
5448 /*
5449 * Get the transition table for the given event and depending on whether we are
5450 * processing the old or the new tuple.
5451 */
5457 {
5464 /*
5465 * For INSERT events NEW should be non-NULL, for DELETE events OLD should
5466 * be non-NULL, whereas for UPDATE events normally both OLD and NEW are
5467 * non-NULL. But for UPDATE events fired for capturing transition tuples
5468 * during UPDATE partition-key row movement, OLD is NULL when the event is
5469 * for a row being inserted, whereas NEW is NULL when the event is for a
5470 * row being deleted.
5471 */
5478 {
5484 }
5486 {
5492 }
5495 }
5497 /*
5498 * Add the given heap tuple to the given tuplestore, applying the conversion
5499 * map if necessary.
5500 *
5501 * If original_insert_tuple is given, we can add that tuple without conversion.
5502 */
5503 static void
5510 {
5513 /*
5514 * Nothing needs to be done if we don't have a tuplestore.
5515 */
5522 {
5529 }
5530 else
5532 }
5534 /* ----------
5535 * AfterTriggerEnlargeQueryState()
5536 *
5537 * Prepare the necessary state so that we can record AFTER trigger events
5538 * queued by a query. It is allowed to have nested queries within a
5539 * (sub)transaction, so we need to have separate state for each query
5540 * nesting level.
5541 * ----------
5542 */
5543 static void
5545 {
5551 {
5558 }
5559 else
5560 {
5561 /* repalloc will keep the stack in the same context */
5570 }
5572 /* Initialize new array entries to empty */
5574 {
5584 }
5585 }
5587 /*
5588 * Create an empty SetConstraintState with room for numalloc trigstates
5589 */
5590 static SetConstraintState
5592 {
5593 SetConstraintState state;
5595 /* Behave sanely with numalloc == 0 */
5599 /*
5600 * We assume that zeroing will correctly initialize the state values.
5601 */
5610 }
5612 /*
5613 * Copy a SetConstraintState
5614 */
5615 static SetConstraintState
5617 {
5618 SetConstraintState state;
5629 }
5631 /*
5632 * Add a per-trigger item to a SetConstraintState. Returns possibly-changed
5633 * pointer to the state object (it will change if we have to repalloc).
5634 */
5635 static SetConstraintState
5638 {
5640 {
5650 }
5657 }
5659 /* ----------
5660 * AfterTriggerSetState()
5661 *
5662 * Execute the SET CONSTRAINTS ... utility command.
5663 * ----------
5664 */
5665 void
5667 {
5670 /* If we haven't already done so, initialize our state. */
5674 /*
5675 * If in a subtransaction, and we didn't save the current state already,
5676 * save it so it can be restored if the subtransaction aborts.
5677 */
5680 {
5683 }
5685 /*
5686 * Handle SET CONSTRAINTS ALL ...
5687 */
5689 {
5690 /*
5691 * Forget any previous SET CONSTRAINTS commands in this transaction.
5692 */
5695 /*
5696 * Set the per-transaction ALL state to known.
5697 */
5700 }
5701 else
5702 {
5703 Relation conrel;
5704 Relation tgrel;
5709 /*
5710 * Handle SET CONSTRAINTS constraint-name [, ...]
5711 *
5712 * First, identify all the named constraints and make a list of their
5713 * OIDs. Since, unlike the SQL spec, we allow multiple constraints of
5714 * the same name within a schema, the specifications are not
5715 * necessarily unique. Our strategy is to target all matching
5716 * constraints within the first search-path schema that has any
5717 * matches, but disregard matches in schemas beyond the first match.
5718 * (This is a bit odd but it's the historical behavior.)
5719 *
5720 * A constraint in a partitioned table may have corresponding
5721 * constraints in the partitions. Grab those too.
5722 */
5726 {
5733 {
5740 }
5742 /*
5743 * If we're given the schema name with the constraint, look only
5744 * in that schema. If given a bare constraint name, use the
5745 * search path to find the first matching constraint.
5746 */
5748 {
5753 }
5754 else
5755 {
5757 }
5761 {
5763 SysScanDesc conscan;
5765 HeapTuple tup;
5768 Anum_pg_constraint_conname,
5772 Anum_pg_constraint_connamespace,
5780 {
5791 }
5795 /*
5796 * Once we've found a matching constraint we do not search
5797 * later parts of the search path.
5798 */
5801 }
5805 /*
5806 * Not found ?
5807 */
5813 }
5815 /*
5816 * Scan for any possible descendants of the constraints. We append
5817 * whatever we find to the same list that we're scanning; this has the
5818 * effect that we create new scans for those, too, so if there are
5819 * further descendents, we'll also catch them.
5820 */
5822 {
5824 ScanKeyData key;
5825 SysScanDesc scan;
5826 HeapTuple tuple;
5829 Anum_pg_constraint_conparentid,
5836 {
5840 }
5843 }
5847 /*
5848 * Now, locate the trigger(s) implementing each of these constraints,
5849 * and make a list of their OIDs.
5850 */
5854 {
5856 ScanKeyData skey;
5857 SysScanDesc tgscan;
5858 HeapTuple htup;
5861 Anum_pg_trigger_tgconstraint,
5869 {
5872 /*
5873 * Silently skip triggers that are marked as non-deferrable in
5874 * pg_trigger. This is not an error condition, since a
5875 * deferrable RI constraint may have some non-deferrable
5876 * actions.
5877 */
5880 }
5883 }
5887 /*
5888 * Now we can set the trigger states of individual triggers for this
5889 * xact.
5890 */
5892 {
5899 {
5901 {
5905 }
5906 }
5908 {
5911 }
5912 }
5913 }
5915 /*
5916 * SQL99 requires that when a constraint is set to IMMEDIATE, any deferred
5917 * checks against that constraint must be made when the SET CONSTRAINTS
5918 * command is executed -- i.e. the effects of the SET CONSTRAINTS command
5919 * apply retroactively. We've updated the constraints state, so scan the
5920 * list of previously deferred events to fire any that have now become
5921 * immediate.
5922 *
5923 * Obviously, if this was SET ... DEFERRED then it can't have converted
5924 * any unfired events to immediate, so we need do nothing in that case.
5925 */
5927 {
5932 {
5935 /*
5936 * Make sure a snapshot has been established in case trigger
5937 * functions need one. Note that we avoid setting a snapshot if
5938 * we don't find at least one trigger that has to be fired now.
5939 * This is so that BEGIN; SET CONSTRAINTS ...; SET TRANSACTION
5940 * ISOLATION LEVEL SERIALIZABLE; ... works properly. (If we are
5941 * at the start of a transaction it's not possible for any trigger
5942 * events to be queued yet.)
5943 */
5945 {
5948 }
5950 /*
5951 * We can delete fired events if we are at top transaction level,
5952 * but we'd better not if inside a subtransaction, since the
5953 * subtransaction could later get rolled back.
5954 */
5958 }
5962 }
5963 }
5965 /* ----------
5966 * AfterTriggerPendingOnRel()
5967 * Test to see if there are any pending after-trigger events for rel.
5968 *
5969 * This is used by TRUNCATE, CLUSTER, ALTER TABLE, etc to detect whether
5970 * it is unsafe to perform major surgery on a relation. Note that only
5971 * local pending events are examined. We assume that having exclusive lock
5972 * on a rel guarantees there are no unserviced events in other backends ---
5973 * but having a lock does not prevent there being such events in our own.
5974 *
5975 * In some scenarios it'd be reasonable to remove pending events (more
5976 * specifically, mark them DONE by the current subxact) but without a lot
5977 * of knowledge of the trigger semantics we can't do this in general.
5978 * ----------
5979 */
5980 bool
5982 {
5983 AfterTriggerEvent event;
5987 /* Scan queued events */
5989 {
5992 /*
5993 * We can ignore completed events. (Even if a DONE flag is rolled
5994 * back by subxact abort, it's OK because the effects of the TRUNCATE
5995 * or whatever must get rolled back too.)
5996 */
6002 }
6004 /*
6005 * Also scan events queued by incomplete queries. This could only matter
6006 * if TRUNCATE/etc is executed by a function or trigger within an updating
6007 * query on the same relation, which is pretty perverse, but let's check.
6008 */
6009 for (depth = 0; depth <= afterTriggers.query_depth && depth < afterTriggers.maxquerydepth; depth++)
6010 {
6012 {
6020 }
6021 }
6024 }
6026 /* ----------
6027 * AfterTriggerSaveEvent()
6028 *
6029 * Called by ExecA[RS]...Triggers() to queue up the triggers that should
6030 * be fired for an event.
6031 *
6032 * NOTE: this is called whenever there are any triggers associated with
6033 * the event (even if they are disabled). This function decides which
6034 * triggers actually need to be queued. It is also called after each row,
6035 * even if there are no triggers for that event, if there are any AFTER
6036 * STATEMENT triggers for the statement which use transition tables, so that
6037 * the transition tuplestores can be built. Furthermore, if the transition
6038 * capture is happening for UPDATEd rows being moved to another partition due
6039 * to the partition-key being changed, then this function is called once when
6040 * the row is deleted (to capture OLD row), and once when the row is inserted
6041 * into another partition (to capture NEW row). This is done separately because
6042 * DELETE and INSERT happen on different tables.
6043 *
6044 * Transition tuplestores are built now, rather than when events are pulled
6045 * off of the queue because AFTER ROW triggers are allowed to select from the
6046 * transition tables for the statement.
6047 *
6048 * This contains special support to queue the update events for the case where
6049 * a partitioned table undergoing a cross-partition update may have foreign
6050 * keys pointing into it. Normally, a partitioned table's row triggers are
6051 * not fired because the leaf partition(s) which are modified as a result of
6052 * the operation on the partitioned table contain the same triggers which are
6053 * fired instead. But that general scheme can cause problematic behavior with
6054 * foreign key triggers during cross-partition updates, which are implemented
6055 * as DELETE on the source partition followed by INSERT into the destination
6056 * partition. Specifically, firing DELETE triggers would lead to the wrong
6057 * foreign key action to be enforced considering that the original command is
6058 * UPDATE; in this case, this function is called with relinfo as the
6059 * partitioned table, and src_partinfo and dst_partinfo referring to the
6060 * source and target leaf partitions, respectively.
6061 *
6062 * is_crosspart_update is true either when a DELETE event is fired on the
6063 * source partition (which is to be ignored) or an UPDATE event is fired on
6064 * the root partitioned table.
6065 * ----------
6066 */
6067 static void
6076 {
6079 AfterTriggerEventData new_event;
6080 AfterTriggerSharedData new_shared;
6087 /*
6088 * Check state. We use a normal test not Assert because it is possible to
6089 * reach here in the wrong state given misconfigured RI triggers, in
6090 * particular deferring a cascade action trigger.
6091 */
6095 /* Be sure we have enough space to record events at this query depth. */
6099 /*
6100 * If the directly named relation has any triggers with transition tables,
6101 * then we need to capture transition tuples.
6102 */
6104 {
6107 /*
6108 * Capture the old tuple in the appropriate transition table based on
6109 * the event.
6110 */
6112 {
6116 oldslot,
6117 NULL,
6118 transition_capture);
6121 }
6123 /*
6124 * Capture the new tuple in the appropriate transition table based on
6125 * the event.
6126 */
6128 {
6132 NULL,
6133 newslot,
6134 transition_capture);
6137 }
6139 /*
6140 * If transition tables are the only reason we're here, return. As
6141 * mentioned above, we can also be here during update tuple routing in
6142 * presence of transition tables, in which case this function is
6143 * called separately for OLD and NEW, so we expect exactly one of them
6144 * to be NULL.
6145 */
6152 }
6154 /*
6155 * We normally don't see partitioned tables here for row level triggers
6156 * except in the special case of a cross-partition update. In that case,
6157 * nodeModifyTable.c:ExecCrossPartitionUpdateForeignKey() calls here to
6158 * queue an update event on the root target partitioned table, also
6159 * passing the source and destination partitions and their tuples.
6160 */
6167 /*
6168 * Validate the event code and collect the associated tuple CTIDs.
6169 *
6170 * The event code will be used both as a bitmask and an array offset, so
6171 * validation is important to make sure we don't walk off the edge of our
6172 * arrays.
6173 *
6174 * Also, if we're considering statement-level triggers, check whether we
6175 * already queued a set of them for this event, and cancel the prior set
6176 * if so. This preserves the behavior that statement-level triggers fire
6177 * just once per statement and fire after row-level triggers.
6178 */
6180 {
6184 {
6189 }
6190 else
6191 {
6198 }
6203 {
6208 }
6209 else
6210 {
6217 }
6222 {
6228 /*
6229 * Also remember the OIDs of partitions to fetch these tuples
6230 * out of later in AfterTriggerExecute().
6231 */
6233 {
6239 }
6240 }
6241 else
6242 {
6249 }
6262 }
6264 /* Determine flags */
6266 {
6268 {
6271 else
6273 }
6274 else
6276 }
6278 /* else, we'll initialize ate_flags for each trigger */
6282 /*
6283 * Must convert/copy the source and destination partition tuples into the
6284 * root partitioned table's format/slot, because the processing in the
6285 * loop below expects both oldslot and newslot tuples to be in that form.
6286 */
6288 {
6296 oldslot,
6297 rootslot);
6298 else
6305 newslot,
6306 rootslot);
6307 else
6309 }
6312 {
6316 tgtype_level,
6317 TRIGGER_TYPE_AFTER,
6318 tgtype_event))
6325 {
6327 {
6330 }
6331 else
6332 /* subsequent event for the same tuple */
6334 }
6336 /*
6337 * If the trigger is a foreign key enforcement trigger, there are
6338 * certain cases where we can skip queueing the event because we can
6339 * tell by inspection that the FK constraint will still pass. There
6340 * are also some cases during cross-partition updates of a partitioned
6341 * table where queuing the event can be skipped.
6342 */
6344 {
6346 {
6349 /*
6350 * For cross-partitioned updates of partitioned PK table,
6351 * skip the event fired by the component delete on the
6352 * source leaf partition unless the constraint originates
6353 * in the partition itself (!tgisclone), because the
6354 * update event that will be fired on the root
6355 * (partitioned) target table will be used to perform the
6356 * necessary foreign key enforcement action.
6357 */
6363 /* Update or delete on trigger's PK table */
6366 {
6367 /* skip queuing this event */
6369 }
6374 /*
6375 * Update on trigger's FK table. We can skip the update
6376 * event fired on a partitioned table during a
6377 * cross-partition of that table, because the insert event
6378 * that is fired on the destination leaf partition would
6379 * suffice to perform the necessary foreign key check.
6380 * Moreover, RI_FKey_fk_upd_check_required() expects to be
6381 * passed a tuple that contains system attributes, most of
6382 * which are not present in the virtual slot belonging to
6383 * a partitioned table.
6384 */
6388 {
6389 /* skip queuing this event */
6391 }
6396 /*
6397 * Not an FK trigger. No need to queue the update event
6398 * fired during a cross-partitioned update of a
6399 * partitioned table, because the same row trigger must be
6400 * present in the leaf partition(s) that are affected as
6401 * part of this update and the events fired on them are
6402 * queued instead.
6403 */
6408 }
6409 }
6411 /*
6412 * If the trigger is a deferred unique constraint check trigger, only
6413 * queue it if the unique constraint was potentially violated, which
6414 * we know from index insertion time.
6415 */
6417 {
6420 }
6422 /*
6423 * Fill in event structure and add it to the current query's queue.
6424 * Note we set ats_table to NULL whenever this trigger doesn't use
6425 * transition tables, to improve sharability of the shared event data.
6426 */
6438 else
6444 }
6446 /*
6447 * Finally, spool any foreign tuple(s). The tuplestore squashes them to
6448 * minimal tuples, so this loses any system columns. The executor lost
6449 * those columns before us, for an unrelated reason, so this is fine.
6450 */
6452 {
6457 }
6458 }
6460 /*
6461 * Detect whether we already queued BEFORE STATEMENT triggers for the given
6462 * relation + operation, and set the flag so the next call will report "true".
6463 */
6464 static bool
6466 {
6470 /* Check state, like AfterTriggerSaveEvent. */
6474 /* Be sure we have enough space to record events at this query depth. */
6478 /*
6479 * We keep this state in the AfterTriggersTableData that also holds
6480 * transition tables for the relation + operation. In this way, if we are
6481 * forced to make a new set of transition tables because more tuples get
6482 * entered after we've already fired triggers, we will allow a new set of
6483 * statement triggers to get queued.
6484 */
6489 }
6491 /*
6492 * If we previously queued a set of AFTER STATEMENT triggers for the given
6493 * relation + operation, and they've not been fired yet, cancel them. The
6494 * caller will queue a fresh set that's after any row-level triggers that may
6495 * have been queued by the current sub-statement, preserving (as much as
6496 * possible) the property that AFTER ROW triggers fire before AFTER STATEMENT
6497 * triggers, and that the latter only fire once. This deals with the
6498 * situation where several FK enforcement triggers sequentially queue triggers
6499 * for the same table into the same trigger query level. We can't fully
6500 * prevent odd behavior though: if there are AFTER ROW triggers taking
6501 * transition tables, we don't want to change the transition tables once the
6502 * first such trigger has seen them. In such a case, any additional events
6503 * will result in creating new transition tables and allowing new firings of
6504 * statement triggers.
6505 *
6506 * This also saves the current event list location so that a later invocation
6507 * of this function can cheaply find the triggers we're about to queue and
6508 * cancel them.
6509 */
6510 static void
6512 {
6516 /*
6517 * We keep this state in the AfterTriggersTableData that also holds
6518 * transition tables for the relation + operation. In this way, if we are
6519 * forced to make a new set of transition tables because more tuples get
6520 * entered after we've already fired triggers, we will allow a new set of
6521 * statement triggers to get queued without canceling the old ones.
6522 */
6526 {
6527 /*
6528 * We want to start scanning from the tail location that existed just
6529 * before we inserted any statement triggers. But the events list
6530 * might've been entirely empty then, in which case scan from the
6531 * current head.
6532 */
6533 AfterTriggerEvent event;
6537 {
6540 }
6541 else
6542 {
6545 }
6548 {
6552 {
6555 /*
6556 * Exit loop when we reach events that aren't AS triggers for
6557 * the target relation.
6558 */
6567 /* OK, mark it DONE */
6570 }
6571 /* signal we must reinitialize event ptr for next chunk */
6573 }
6574 }
6575 done:
6577 /* In any case, save current insertion point for next time */
6580 }
6582 /*
6583 * GUC assign_hook for session_replication_role
6584 */
6585 void
6587 {
6588 /*
6589 * Must flush the plan cache when changing replication role; but don't
6590 * flush unnecessarily.
6591 */
6594 }
6596 /*
6597 * SQL function pg_trigger_depth()
6598 */
6599 Datum
6601 {
6603 }