/*------------------------------------------------------------------------- * * trigger . c * PostgreSQL TRIGGERs support code . * * Portions Copyright ( c ) 1996 - 2025 , PostgreSQL Global Development Group * Portions Copyright ( c ) 1994 , Regents of the University of California * * IDENTIFICATION * src / backend / commands / trigger . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "postgres.h" #include "access/genam.h" #include "access/htup_details.h" #include "access/relation.h" #include "access/sysattr.h" #include "access/table.h" #include "access/tableam.h" #include "access/xact.h" #include "catalog/catalog.h" #include "catalog/dependency.h" #include "catalog/indexing.h" #include "catalog/objectaccess.h" #include "catalog/partition.h" #include "catalog/pg_constraint.h" #include "catalog/pg_inherits.h" #include "catalog/pg_proc.h" #include "catalog/pg_trigger.h" #include "catalog/pg_type.h" #include "commands/dbcommands.h" #include "commands/trigger.h" #include "executor/executor.h" #include "miscadmin.h" #include "nodes/bitmapset.h" #include "nodes/makefuncs.h" #include "optimizer/optimizer.h" #include "parser/parse_clause.h" #include "parser/parse_collate.h" #include "parser/parse_func.h" #include "parser/parse_relation.h" #include "partitioning/partdesc.h" #include "pgstat.h" #include "rewrite/rewriteHandler.h" #include "rewrite/rewriteManip.h" #include "storage/lmgr.h" #include "utils/acl.h" #include "utils/builtins.h" #include "utils/fmgroids.h" #include "utils/guc_hooks.h" #include "utils/inval.h" #include "utils/lsyscache.h" #include "utils/memutils.h" #include "utils/plancache.h" #include "utils/rel.h" #include "utils/snapmgr.h" #include "utils/syscache.h" #include "utils/tuplestore.h" /* GUC variables */ int SessionReplicationRole = SESSION_REPLICATION_ROLE_ORIGIN;/* How many levels deep into trigger execution are we? */ static int MyTriggerDepth = 0 ;/* Local function prototypes */ static void renametrig_internal(Relation tgrel, Relation targetrel,const char *newname,const char *expected_name);static void renametrig_partition(Relation tgrel, Oid partitionId,const char *newname,const char *expected_name);static void SetTriggerFlags(TriggerDesc *trigdesc, Trigger *trigger);static bool GetTupleForTrigger(EState *estate,bool do_epq_recheck,static bool TriggerEnabled(EState *estate, ResultRelInfo *relinfo,static HeapTuple ExecCallTriggerFunc(TriggerData *trigdata,int tgindx,static void AfterTriggerSaveEvent(EState *estate, ResultRelInfo *relinfo,int event, bool row_trigger,bool is_crosspart_update);static void AfterTriggerEnlargeQueryState(void );static bool before_stmt_triggers_fired(Oid relid, CmdType cmdType);static HeapTuple check_modified_virtual_generated(TupleDesc tupdesc, HeapTuple tuple);/* * Create a trigger . Returns the address of the created trigger . * * queryString is the source text of the CREATE TRIGGER command . * This must be supplied if a whenClause is specified , else it can be NULL . * * relOid , if nonzero , is the relation on which the trigger should be * created . If zero , the name provided in the statement will be looked up . * * refRelOid , if nonzero , is the relation to which the constraint trigger * refers . If zero , the constraint relation name provided in the statement * will be looked up as needed . * * constraintOid , if nonzero , says that this trigger is being created * internally to implement that constraint . A suitable pg_depend entry will * be made to link the trigger to that constraint . constraintOid is zero when * executing a user - entered CREATE TRIGGER command . ( For CREATE CONSTRAINT * TRIGGER , we build a pg_constraint entry internally . ) * * indexOid , if nonzero , is the OID of an index associated with the constraint . * We do nothing with this except store it into pg_trigger . tgconstrindid ; * but when creating a trigger for a deferrable unique constraint on a * partitioned table , its children are looked up . Note we don ' t cope with * invalid indexes in that case . * * funcoid , if nonzero , is the OID of the function to invoke . When this is * given , stmt - > funcname is ignored . * * parentTriggerOid , if nonzero , is a trigger that begets this one ; so that * if that trigger is dropped , this one should be too . There are two cases * when a nonzero value is passed for this : 1 ) when this function recurses to * create the trigger on partitions , 2 ) when creating child foreign key * triggers ; see CreateFKCheckTrigger ( ) and createForeignKeyActionTriggers ( ) . * * If whenClause is passed , it is an already - transformed expression for * WHEN . In this case , we ignore any that may come in stmt - > whenClause . * * If isInternal is true then this is an internally - generated trigger . * This argument sets the tgisinternal field of the pg_trigger entry , and * if true causes us to modify the given trigger name to ensure uniqueness . * * When isInternal is not true we require ACL_TRIGGER permissions on the * relation , as well as ACL_EXECUTE on the trigger function . For internal * triggers the caller must apply any required permission checks . * * When called on partitioned tables , this function recurses to create the * trigger on all the partitions , except if isInternal is true , in which * case caller is expected to execute recursion on its own . in_partition * indicates such a recursive call ; outside callers should pass " false " * ( but see CloneRowTriggersToPartition ) . const char *queryString,bool isInternal, bool in_partition)return /* * Like the above ; additionally the firing condition * ( always / origin / replica / disabled ) can be specified . const char *queryString,bool isInternal, bool in_partition,char trigger_fires_when)int ncolumns;char *qual;bool nulls[Natts_pg_trigger];char internaltrigname[NAMEDATALEN];char *trigname;char *oldtablename = NULL;char *newtablename = NULL;bool partition_recurse;bool trigger_exists = false ;bool existing_isInternal = false ;bool existing_isClone = false ;if (OidIsValid(relOid))else /* * Triggers must be on tables or views , and there are additional * relation - type - specific restrictions . if (rel->rd_rel->relkind == RELKIND_RELATION)/* Tables can't have INSTEAD OF triggers */ if (stmt->timing != TRIGGER_TYPE_BEFORE &&"\" %s\" is a table" ,"Tables cannot have INSTEAD OF triggers." )));else if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)/* Partitioned tables can't have INSTEAD OF triggers */ if (stmt->timing != TRIGGER_TYPE_BEFORE &&"\" %s\" is a table" ,"Tables cannot have INSTEAD OF triggers." )));/* * FOR EACH ROW triggers have further restrictions if (stmt->row)/* * Disallow use of transition tables . * * Note that we have another restriction about transition tables * in partitions ; search for ' has_superclass ' below for an * explanation . The check here is just to protect from the fact * that if we allowed it here , the creation would succeed for a * partitioned table with no partitions , but would be blocked by * the other restriction when the first partition was created , * which is very unfriendly behavior . if (stmt->transitionRels != NIL)"\" %s\" is a partitioned table" ,"ROW triggers with transition tables are not supported on partitioned tables." )));else if (rel->rd_rel->relkind == RELKIND_VIEW)/* * Views can have INSTEAD OF triggers ( which we check below are * row - level ) , or statement - level BEFORE / AFTER triggers . if (stmt->timing != TRIGGER_TYPE_INSTEAD && stmt->row)"\" %s\" is a view" ,"Views cannot have row-level BEFORE or AFTER triggers." )));/* Disallow TRUNCATE triggers on VIEWs */ if (TRIGGER_FOR_TRUNCATE(stmt->events))"\" %s\" is a view" ,"Views cannot have TRUNCATE triggers." )));else if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)if (stmt->timing != TRIGGER_TYPE_BEFORE &&"\" %s\" is a foreign table" ,"Foreign tables cannot have INSTEAD OF triggers." )));/* * We disallow constraint triggers to protect the assumption that * triggers on FKs can ' t be deferred . See notes with AfterTriggers * data structures , below . if (stmt->isconstraint)"\" %s\" is a foreign table" ,"Foreign tables cannot have constraint triggers." )));else "relation \" %s\" cannot have triggers" ,if (!allowSystemTableMods && IsSystemRelation(rel))"permission denied: \" %s\" is a system catalog" ,if (stmt->isconstraint)/* * We must take a lock on the target relation to protect against * concurrent drop . It ' s not clear that AccessShareLock is strong * enough , but we certainly need at least that much . . . otherwise , we * might end up creating a pg_constraint entry referencing a * nonexistent table . if (OidIsValid(refRelOid))else if (stmt->constrrel != NULL)false );/* permission checks */ if (!isInternal)if (aclresult != ACLCHECK_OK)if (OidIsValid(constrrelid))if (aclresult != ACLCHECK_OK)/* * When called on a partitioned table to create a FOR EACH ROW trigger * that ' s not internal , we create one trigger for each partition , too . * * For that , we ' d better hold lock on all of them ahead of time . if (partition_recurse)/* Compute tgtype */ if (stmt->row)/* Disallow ROW-level TRUNCATE triggers */ if (TRIGGER_FOR_ROW(tgtype) && TRIGGER_FOR_TRUNCATE(tgtype))"TRUNCATE FOR EACH ROW triggers are not supported" )));/* INSTEAD triggers must be row-level, and can't have WHEN or columns */ if (TRIGGER_FOR_INSTEAD(tgtype))if (!TRIGGER_FOR_ROW(tgtype))"INSTEAD OF triggers must be FOR EACH ROW" )));if (stmt->whenClause)"INSTEAD OF triggers cannot have WHEN conditions" )));if (stmt->columns != NIL)"INSTEAD OF triggers cannot have column lists" )));/* * We don ' t yet support naming ROW transition variables , but the parser * recognizes the syntax so we can give a nicer message here . * * Per standard , REFERENCING TABLE names are only allowed on AFTER * triggers . Per standard , REFERENCING ROW names are not allowed with FOR * EACH STATEMENT . Per standard , each OLD / NEW , ROW / TABLE permutation is * only allowed once . Per standard , OLD may not be specified when * creating a trigger only for INSERT , and NEW may not be specified when * creating a trigger only for DELETE . * * Notice that the standard allows an AFTER . . . FOR EACH ROW trigger to * reference both ROW and TABLE transition data . if (stmt->transitionRels != NIL)if (!(tt->isTable))"ROW variable naming in the REFERENCING clause is not supported" ),"Use OLD TABLE or NEW TABLE for naming transition tables." )));/* * Because of the above test , we omit further ROW - related testing * below . If we later allow naming OLD and NEW ROW variables , * adjustments will be needed below . if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)"\" %s\" is a foreign table" ,"Triggers on foreign tables cannot have transition tables." )));if (rel->rd_rel->relkind == RELKIND_VIEW)"\" %s\" is a view" ,"Triggers on views cannot have transition tables." )));/* * We currently don ' t allow row - level triggers with transition * tables on partition or inheritance children . Such triggers * would somehow need to see tuples converted to the format of the * table they ' re attached to , and it ' s not clear which subset of * tuples each child should see . See also the prohibitions in * ATExecAttachPartition ( ) and ATExecAddInherit ( ) . if (TRIGGER_FOR_ROW(tgtype) && has_superclass(rel->rd_id))/* Use appropriate error message. */ if (rel->rd_rel->relispartition)"ROW triggers with transition tables are not supported on partitions" )));else "ROW triggers with transition tables are not supported on inheritance children" )));if (stmt->timing != TRIGGER_TYPE_AFTER)"transition table name can only be specified for an AFTER trigger" )));if (TRIGGER_FOR_TRUNCATE(tgtype))"TRUNCATE triggers with transition tables are not supported" )));/* * We currently don ' t allow multi - event triggers ( " INSERT OR * UPDATE " ) with transition tables , because it ' s not clear how to * handle INSERT . . . ON CONFLICT statements which can fire both * INSERT and UPDATE triggers . We show the inserted tuples to * INSERT triggers and the updated tuples to UPDATE triggers , but * it ' s not yet clear what INSERT OR UPDATE trigger should see . * This restriction could be lifted if we can decide on the right * semantics in a later release . if (((TRIGGER_FOR_INSERT(tgtype) ? 1 : 0 ) +1 : 0 ) +1 : 0 )) != 1 )"transition tables cannot be specified for triggers with more than one event" )));/* * We currently don ' t allow column - specific triggers with * transition tables . Per spec , that seems to require * accumulating separate transition tables for each combination of * columns , which is a lot of work for a rather marginal feature . if (stmt->columns != NIL)"transition tables cannot be specified for triggers with column lists" )));/* * We disallow constraint triggers with transition tables , to * protect the assumption that such triggers can ' t be deferred . * See notes with AfterTriggers data structures , below . * * Currently this is enforced by the grammar , so just Assert here . if (tt->isNew)if (!(TRIGGER_FOR_INSERT(tgtype) ||"NEW TABLE can only be specified for an INSERT or UPDATE trigger" )));if (newtablename != NULL)"NEW TABLE cannot be specified multiple times" )));else if (!(TRIGGER_FOR_DELETE(tgtype) ||"OLD TABLE can only be specified for a DELETE or UPDATE trigger" )));if (oldtablename != NULL)"OLD TABLE cannot be specified multiple times" )));if (newtablename != NULL && oldtablename != NULL &&0 )"OLD TABLE name and NEW TABLE name cannot be the same" )));/* * Parse the WHEN clause , if any and we weren ' t passed an already * transformed one . * * Note that as a side effect , we fill whenRtable when parsing . If we got * an already parsed clause , this does not occur , which is what we want - - * no point in adding redundant dependencies below . if (!whenClause && stmt->whenClause)/* Set up a pstate to parse with */ /* * Set up nsitems for OLD and NEW references . * * ' OLD ' must always have varno equal to 1 and ' NEW ' equal to 2 . "old" , NIL),false , false );false , true , true );"new" , NIL),false , false );false , true , true );/* Transform expression. Copy to be sure we don't modify original */ "WHEN" );/* we have to fix its collations too */ /* * Check for disallowed references to OLD / NEW . * * NB : pull_var_clause is okay here only because we don ' t allow * subselects in WHEN clauses ; it would fail to examine the contents * of subselects . 0 );switch (var->varno)case PRS2_OLD_VARNO:if (!TRIGGER_FOR_ROW(tgtype))"statement trigger's WHEN condition cannot reference column values" ),if (TRIGGER_FOR_INSERT(tgtype))"INSERT trigger's WHEN condition cannot reference OLD values" ),/* system columns are okay here */ break ;case PRS2_NEW_VARNO:if (!TRIGGER_FOR_ROW(tgtype))"statement trigger's WHEN condition cannot reference column values" ),if (TRIGGER_FOR_DELETE(tgtype))"DELETE trigger's WHEN condition cannot reference NEW values" ),if (var->varattno < 0 && TRIGGER_FOR_BEFORE(tgtype))"BEFORE trigger's WHEN condition cannot reference NEW system columns" ),if (TRIGGER_FOR_BEFORE(tgtype) &&0 &&"BEFORE trigger's WHEN condition cannot reference NEW generated columns" ),"A whole-row reference is used and the table contains generated columns." ),if (TRIGGER_FOR_BEFORE(tgtype) &&0 &&1 )->attgenerated)"BEFORE trigger's WHEN condition cannot reference NEW generated columns" ),"Column \" %s\" is a generated column." ,1 )->attname)),break ;default :/* can't happen without add_missing_from, so just elog */ "trigger WHEN condition cannot contain references to other relations" );break ;/* we'll need the rtable for recordDependencyOnExpr */ else if (!whenClause)else /* * Find and validate the trigger function . if (!OidIsValid(funcoid))0 , NULL, false );if (!isInternal)if (aclresult != ACLCHECK_OK)if (funcrettype != TRIGGEROID)"function %s must return type %s" ,"trigger" )));/* * Scan pg_trigger to see if there is already a trigger of the same name . * Skip this for internally generated triggers , since we ' ll modify the * name to be unique below . * * NOTE that this is cool only because we have ShareRowExclusiveLock on * the relation , so the trigger set won ' t be changing underneath us . if (!isInternal)2 ];0 ],1 ],true ,2 , skeys);/* There should be at most one matching tuple */ if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))true ;/* copy the tuple to use in CatalogTupleUpdate() */ if (!trigger_exists)/* Generate the OID for the new trigger. */ else /* * If OR REPLACE was specified , we ' ll replace the old trigger ; * otherwise complain about the duplicate name . if (!stmt->replace)"trigger \" %s\" for relation \" %s\" already exists" ,/* * An internal trigger or a child trigger ( isClone ) cannot be replaced * by a user - defined trigger . However , skip this test when * in_partition , because then we ' re recursing from a partitioned table * and the check was made at the parent level . if ((existing_isInternal || existing_isClone) &&"trigger \" %s\" for relation \" %s\" is an internal or a child trigger" ,/* * It is not allowed to replace with a constraint trigger ; gram . y * should have enforced this already . /* * It is not allowed to replace an existing constraint trigger , * either . ( The reason for these restrictions is partly that it seems * difficult to deal with pending trigger events in such cases , and * partly that the command might imply changing the constraint ' s * properties as well , which doesn ' t seem nice . ) if (OidIsValid(existing_constraint_oid))"trigger \" %s\" for relation \" %s\" is a constraint trigger" ,/* * If it ' s a user - entered CREATE CONSTRAINT TRIGGER command , make a * corresponding pg_constraint entry . if (stmt->isconstraint && !OidIsValid(constraintOid))/* Internal callers should have made their own constraints */ true , /* Is Enforced */ true ,/* no parent */ /* no conkey */ 0 ,0 ,/* no domain */ /* no index */ /* no foreign key */ 0 ,' ' ,' ' ,0 ,' ' ,/* no exclusion */ /* no check constraint */ true , /* islocal */ 0 , /* inhcount */ true , /* noinherit */ false , /* conperiod */ /* is_internal */ /* * If trigger is internally generated , modify the provided trigger name to * ensure uniqueness by appending the trigger OID . ( Callers will usually * supply a simple constant trigger name in these cases . ) if (isInternal)sizeof (internaltrigname),"%s_%u" , stmt->trigname, trigoid);else /* user-defined trigger; use the specified trigger name as-is */ /* * Build the new pg_trigger tuple . false , sizeof (nulls));1 ] = ObjectIdGetDatum(trigoid);1 ] = ObjectIdGetDatum(RelationGetRelid(rel));1 ] = ObjectIdGetDatum(parentTriggerOid);1 ] = DirectFunctionCall1(namein,1 ] = ObjectIdGetDatum(funcoid);1 ] = Int16GetDatum(tgtype);1 ] = trigger_fires_when;1 ] = BoolGetDatum(isInternal);1 ] = ObjectIdGetDatum(constrrelid);1 ] = ObjectIdGetDatum(indexOid);1 ] = ObjectIdGetDatum(constraintOid);1 ] = BoolGetDatum(stmt->deferrable);1 ] = BoolGetDatum(stmt->initdeferred);if (stmt->args)char *args;int len = 0 ;char *ar = strVal(lfirst(le));4 ;for (; *ar; ar++)if (*ar == '\\' )char *) palloc(len + 1 );0 ] = '\0' ;char *s = strVal(lfirst(le));char *d = args + strlen(args);while (*s)if (*s == '\\' )'\\' ;"\\000" );1 ] = Int16GetDatum(nargs);1 ] = DirectFunctionCall1(byteain,else 1 ] = Int16GetDatum(0 );1 ] = DirectFunctionCall1(byteain,"" ));/* build column number array if it's a column-specific trigger */ if (ncolumns == 0 )else int i = 0 ;sizeof (int16));char *name = strVal(lfirst(cell));int j;/* Lookup column name. System columns are not allowed */ false );if (attnum == InvalidAttrNumber)"column \" %s\" of relation \" %s\" does not exist" ,/* Check for duplicates */ for (j = i - 1 ; j >= 0 ; j--)if (columns[j] == attnum)"column \" %s\" specified more than once" ,1 ] = PointerGetDatum(tgattr);/* set tgqual if trigger has WHEN clause */ if (qual)1 ] = CStringGetTextDatum(qual);else 1 ] = true ;if (oldtablename)1 ] = DirectFunctionCall1(namein,else 1 ] = true ;if (newtablename)1 ] = DirectFunctionCall1(namein,else 1 ] = true ;/* * Insert or replace tuple in pg_trigger . if (!trigger_exists)else /* free either original or new tuple */ 1 ]));1 ]));1 ]));if (oldtablename)1 ]));if (newtablename)1 ]));/* * Update relation ' s pg_class entry ; if necessary ; and if not , send an SI * message to make other backends ( and this one ) rebuild relcache entries . if (!HeapTupleIsValid(tuple))"cache lookup failed for relation %u" ,if (!((Form_pg_class) GETSTRUCT(tuple))->relhastriggers)true ;else /* * If we ' re replacing a trigger , flush all the old dependencies before * recording new ones . if (trigger_exists)true );/* * Record dependencies for trigger . Always place a normal dependency on * the function . 0 ;0 ;if (isInternal && OidIsValid(constraintOid))/* * Internally - generated trigger for a constraint , so make it an * internal dependency of the constraint . We can skip depending on * the relation ( s ) , as there ' ll be an indirect dependency via the * constraint . 0 ;else /* * User CREATE TRIGGER , so place dependencies . We make trigger be * auto - dropped if its relation is dropped or if the FK relation is * dropped . ( Auto drop is compatible with our pre - 7 . 3 behavior . ) 0 ;if (OidIsValid(constrrelid))0 ;/* Not possible to have an index dependency in this case */ /* * If it ' s a user - specified constraint trigger , make the constraint * internally dependent on the trigger instead of vice versa . if (OidIsValid(constraintOid))0 ;/* * If it ' s a partition trigger , create the partition dependencies . if (OidIsValid(parentTriggerOid))/* If column-specific trigger, add normal dependencies on columns */ if (columns != NULL)int i;for (i = 0 ; i < ncolumns; i++)/* * If it has a WHEN clause , add dependencies on objects mentioned in the * expression ( eg , functions , as well as any columns used ) . if (whenRtable != NIL)/* Post creation hook for new trigger */ 0 ,/* * Lastly , create the trigger on child relations , if needed . if (partition_recurse)true );int i;"part trig clone" ,/* * We don ' t currently expect to be called with a valid indexOid . If * that ever changes then we ' ll need to write code here to find the * corresponding child index . /* Iterate to create the trigger on each existing partition */ for (i = 0 ; i < partdesc->nparts; i++)/* * Initialize our fabricated parse node by copying the original * one , then resetting fields that we pass separately . /* If there is a WHEN clause, create a modified copy of it */ true , trigger_fires_when);/* Keep lock on target rel until end of xact */ return myself;/* * TriggerSetParentTrigger * Set a partition ' s trigger as child of its parent trigger , * or remove the linkage if parentTrigId is InvalidOid . * * This updates the constraint ' s pg_trigger row to show it as inherited , and * adds PARTITION dependencies to prevent the trigger from being deleted * on its own . Alternatively , reverse that . void 1 ];/* * Find the trigger to delete . 0 ],true ,1 , skey);if (!HeapTupleIsValid(tuple))"could not find tuple for trigger %u" , childTrigId);if (OidIsValid(parentTrigId))/* don't allow setting parent for a constraint that already has one */ if (OidIsValid(trigForm->tgparentid))"trigger %u already has a parent trigger" ,else /* * Guts of trigger deletion . void 1 ];/* * Find the trigger to delete . 0 ],true ,1 , skey);if (!HeapTupleIsValid(tup))"could not find tuple for trigger %u" , trigOid);/* * Open and exclusive - lock the relation the trigger belongs to . if (rel->rd_rel->relkind != RELKIND_RELATION &&"relation \" %s\" cannot have triggers" ,if (!allowSystemTableMods && IsSystemRelation(rel))"permission denied: \" %s\" is a system catalog" ,/* * Delete the pg_trigger tuple . /* * We do not bother to try to determine whether any other triggers remain , * which would be needed in order to decide whether it ' s safe to clear the * relation ' s relhastriggers . ( In any case , there might be a concurrent * process adding new triggers . ) Instead , just force a relcache inval to * make other backends ( and this one too ! ) rebuild their relcache entries . * There ' s no great harm in leaving relhastriggers true even if there are * no triggers left . /* Keep lock on trigger's rel until end of xact */ /* * get_trigger_oid - Look up a trigger by name to find its OID . * * If missing_ok is false , throw an error if trigger not found . If * true , just return InvalidOid . const char *trigname, bool missing_ok)2 ];/* * Find the trigger , verify permissions , set up object address 0 ],1 ],true ,2 , skey);if (!HeapTupleIsValid(tup))if (!missing_ok)"trigger \" %s\" for table \" %s\" does not exist" ,else return oid;/* * Perform permissions and integrity checks before acquiring a relation lock . static void const RangeVar *rv, Oid relid, Oid oldrelid,void *arg)if (!HeapTupleIsValid(tuple))return ; /* concurrently dropped */ /* only tables and views can have triggers */ if (form->relkind != RELKIND_RELATION && form->relkind != RELKIND_VIEW &&"relation \" %s\" cannot have triggers" ,/* you must own the table to rename one of its triggers */ if (!object_ownercheck(RelationRelationId, relid, GetUserId()))->relname);if (!allowSystemTableMods && IsSystemClass(relid, form))"permission denied: \" %s\" is a system catalog" ,/* * renametrig - changes the name of a trigger on a relation * * trigger name is changed in trigger catalog . * No record of the previous name is kept . * * get proper relrelation from relation catalog ( if not arg ) * scan trigger catalog * for name conflict ( within rel ) * for original trigger ( if not arg ) * modify tgname in trigger tuple * update row in catalog 2 ];/* * Look up name , check permissions , and acquire lock ( which we will NOT * release until end of transaction ) . 0 ,/* Have lock already, so just need to build relcache entry. */ /* * On partitioned tables , this operation recurses to partitions . Lock all * tables upfront . if (targetrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)void ) find_all_inheritors(relid, AccessExclusiveLock, NULL);/* * Search for the trigger to modify . 0 ],1 ],true ,2 , key);if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))/* * If the trigger descends from a trigger on a parent partitioned * table , reject the rename . We don ' t allow a trigger in a partition * to differ in name from that of its parent : that would lead to an * inconsistency that pg_dump would not reproduce . if (OidIsValid(trigform->tgparentid))"cannot rename trigger \" %s\" on table \" %s\"" ,"Rename the trigger on the partitioned table \" %s\" instead." ,false ))));/* Rename the trigger on this relation ... */ /* ... and if it is partitioned, recurse to its partitions */ if (targetrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)true );for (int i = 0 ; i < partdesc->nparts; i++)else "trigger \" %s\" for table \" %s\" does not exist" ,/* * Close rel , but keep exclusive lock ! return address;/* * Subroutine for renametrig - - perform the actual work of renaming one * trigger on one table . * * If the trigger has a name different from the expected one , raise a * NOTICE about it . static void const char *newname, const char *expected_name)2 ];/* If the trigger already has the new name, nothing to do. */ if (strcmp(NameStr(tgform->tgname), newname) == 0 )return ;/* * Before actually trying the rename , search for triggers with the same * name . The update would fail with an ugly message in that case , and it * is better to throw a nicer error . 0 ],1 ],true ,2 , key);if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))"trigger \" %s\" for relation \" %s\" already exists" ,/* * The target name is free ; update the existing pg_trigger tuple with it . /* need a modifiable copy */ /* * If the trigger has a name different from what we expected , let the user * know . ( We can proceed anyway , since we must have reached here following * a tgparentid link . ) if (strcmp(NameStr(tgform->tgname), expected_name) != 0 )"renamed trigger \" %s\" on relation \" %s\"" ,0 );/* * Invalidate relation ' s relcache entry so that other backends ( and this * one too ! ) are sent SI message to make them rebuild relcache entries . * ( Ideally this should happen automatically . . . ) /* * Subroutine for renametrig - - Helper for recursing to partitions when * renaming triggers on a partitioned table . static void const char *newname, const char *expected_name)/* * Given a relation and the OID of a trigger on parent relation , find the * corresponding trigger in the child and rename that trigger to the given * name . true ,1 , &key);while (HeapTupleIsValid(tuple = systable_getnext(tgscan)))if (tgform->tgparentid != parentTriggerOid)continue ; /* not our trigger */ /* Rename the trigger on this partition */ /* And if this relation is partitioned, recurse to its partitions */ if (partitionRel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)true );for (int i = 0 ; i < partdesc->nparts; i++)/* There should be at most one matching tuple */ break ;/* * EnableDisableTrigger ( ) * * Called by ALTER TABLE ENABLE / DISABLE [ REPLICA | ALWAYS ] TRIGGER * to change ' tgenabled ' field for the specified trigger ( s ) * * rel : relation to process ( caller must hold suitable lock on it ) * tgname : name of trigger to process , or NULL to scan all triggers * tgparent : if not zero , process only triggers with this tgparentid * fires_when : new value for tgenabled field . In addition to generic * enablement / disablement , this also defines when the trigger * should be fired in session replication roles . * skip_system : if true , skip " system " triggers ( constraint triggers ) * recurse : if true , recurse to partitions * * Caller should have checked permissions for the table ; here we also * enforce that superuser privilege is required to alter the state of * system triggers void const char *tgname, Oid tgparent,char fires_when, bool skip_system, bool recurse,int nkeys;2 ];bool found;bool changed;/* Scan the relevant entries in pg_triggers */ 0 ],if (tgname)1 ],2 ;else 1 ;true ,false ;while (HeapTupleIsValid(tuple = systable_getnext(tgscan)))if (OidIsValid(tgparent) && tgparent != oldtrig->tgparentid)continue ;if (oldtrig->tgisinternal)/* system trigger ... ok to process? */ if (skip_system)continue ;if (!superuser())"permission denied: \" %s\" is a system trigger" ,true ;if (oldtrig->tgenabled != fires_when)/* need to change this one ... make a copy to scribble on */ true ;/* * When altering FOR EACH ROW triggers on a partitioned table , do the * same on the partitions as well , unless ONLY is specified . * * Note that we recurse even if we didn ' t change the trigger above , * because the partitions ' copy of the trigger may have a different * value of tgenabled than the parent ' s trigger and thus might need to * be changed . if (recurse &&true );int i;for (i = 0 ; i < partdesc->nparts; i++)/* Match on child triggers' tgparentid, not their name */ /* keep lock till commit */ 0 );if (tgname && !found)"trigger \" %s\" for table \" %s\" does not exist" ,/* * If we changed anything , broadcast a SI inval message to force each * backend ( including our own ! ) to rebuild relation ' s relcache entry . * Otherwise they will fail to apply the change promptly . if (changed)/* * Build trigger data to attach to the given relcache entry . * * Note that trigger data attached to a relcache entry must be stored in * CacheMemoryContext to ensure it survives as long as the relcache entry . * But we should be running in a less long - lived working context . To avoid * leaking cache memory if this routine fails partway through , we build a * temporary TriggerDesc in working memory and then copy the completed * structure into cache memory . void int numtrigs;int maxtrigs;int i;/* * Allocate a working array to hold the triggers ( the array is extended if * necessary ) 16 ;sizeof (Trigger));0 ;/* * Note : since we scan the triggers using TriggerRelidNameIndexId , we will * be reading the triggers in name order , except possibly during * emergency - recovery operations ( ie , IgnoreSystemIndexes ) . This in turn * ensures that triggers will be fired in name order . true ,1 , &skey);while (HeapTupleIsValid(htup = systable_getnext(tgscan)))bool isnull;if (numtrigs >= maxtrigs)2 ;sizeof (Trigger));/* tgattr is first var-width field, so OK to access directly */ if (build->tgnattr > 0 )sizeof (int16));sizeof (int16));else if (build->tgnargs > 0 )char *p;if (isnull)"tgargs is null in trigger for relation \" %s\"" ,char *) VARDATA_ANY(val);char **) palloc(build->tgnargs * sizeof (char *));for (i = 0 ; i < build->tgnargs; i++)1 ;else if (!isnull)else if (!isnull)else if (!isnull)else /* There might not be any triggers */ if (numtrigs == 0 )return ;/* Build trigdesc */ sizeof (TriggerDesc));for (i = 0 ; i < numtrigs; i++)/* Copy completed trigdesc into cache storage */ /* Release working memory */ /* * Update the TriggerDesc ' s hint flags to include the specified trigger static void /* there are no row-level truncate triggers */ /* * Copy a TriggerDesc data structure . * * The copy is allocated in the current memory context . int i;if (trigdesc == NULL || trigdesc->numtriggers <= 0 )return NULL;sizeof (TriggerDesc));sizeof (TriggerDesc));sizeof (Trigger));sizeof (Trigger));for (i = 0 ; i < trigdesc->numtriggers; i++)if (trigger->tgnattr > 0 )sizeof (int16));sizeof (int16));if (trigger->tgnargs > 0 )char **newargs;char **) palloc(trigger->tgnargs * sizeof (char *));for (j = 0 ; j < trigger->tgnargs; j++)if (trigger->tgqual)if (trigger->tgoldtable)if (trigger->tgnewtable)return newdesc;/* * Free a TriggerDesc data structure . void int i;if (trigdesc == NULL)return ;for (i = 0 ; i < trigdesc->numtriggers; i++)if (trigger->tgnattr > 0 )if (trigger->tgnargs > 0 )while (--(trigger->tgnargs) >= 0 )if (trigger->tgqual)if (trigger->tgoldtable)if (trigger->tgnewtable)/* * Compare two TriggerDesc structures for logical equality . #ifdef NOT_USEDbool int i,/* * We need not examine the hint flags , just the trigger array itself ; if * we have the same triggers with the same types , the flags should match . * * As of 7 . 3 we assume trigger set ordering is significant in the * comparison ; so we just compare corresponding slots of the two sets . * * Note : comparing the stringToNode forms of the WHEN clauses means that * parse column locations will affect the result . This is okay as long as * this function is only used for detecting exact equality , as for example * in checking for staleness of a cache entry . if (trigdesc1 != NULL)if (trigdesc2 == NULL)return false ;if (trigdesc1->numtriggers != trigdesc2->numtriggers)return false ;for (i = 0 ; i < trigdesc1->numtriggers; i++)if (trig1->tgoid != trig2->tgoid)return false ;if (strcmp(trig1->tgname, trig2->tgname) != 0 )return false ;if (trig1->tgfoid != trig2->tgfoid)return false ;if (trig1->tgtype != trig2->tgtype)return false ;if (trig1->tgenabled != trig2->tgenabled)return false ;if (trig1->tgisinternal != trig2->tgisinternal)return false ;if (trig1->tgisclone != trig2->tgisclone)return false ;if (trig1->tgconstrrelid != trig2->tgconstrrelid)return false ;if (trig1->tgconstrindid != trig2->tgconstrindid)return false ;if (trig1->tgconstraint != trig2->tgconstraint)return false ;if (trig1->tgdeferrable != trig2->tgdeferrable)return false ;if (trig1->tginitdeferred != trig2->tginitdeferred)return false ;if (trig1->tgnargs != trig2->tgnargs)return false ;if (trig1->tgnattr != trig2->tgnattr)return false ;if (trig1->tgnattr > 0 &&sizeof (int16)) != 0 )return false ;for (j = 0 ; j < trig1->tgnargs; j++)if (strcmp(trig1->tgargs[j], trig2->tgargs[j]) != 0 )return false ;if (trig1->tgqual == NULL && trig2->tgqual == NULL)/* ok */ ; else if (trig1->tgqual == NULL || trig2->tgqual == NULL)return false ;else if (strcmp(trig1->tgqual, trig2->tgqual) != 0 )return false ;if (trig1->tgoldtable == NULL && trig2->tgoldtable == NULL)/* ok */ ; else if (trig1->tgoldtable == NULL || trig2->tgoldtable == NULL)return false ;else if (strcmp(trig1->tgoldtable, trig2->tgoldtable) != 0 )return false ;if (trig1->tgnewtable == NULL && trig2->tgnewtable == NULL)/* ok */ ; else if (trig1->tgnewtable == NULL || trig2->tgnewtable == NULL)return false ;else if (strcmp(trig1->tgnewtable, trig2->tgnewtable) != 0 )return false ;else if (trigdesc2 != NULL)return false ;return true ;#endif /* NOT_USED */ /* * Check if there is a row - level trigger with transition tables that prevents * a table from becoming an inheritance child or partition . Return the name * of the first such incompatible trigger , or NULL if there is none . const char *if (trigdesc != NULL)int i;for (i = 0 ; i < trigdesc->numtriggers; ++i)if (!TRIGGER_FOR_ROW(trigger->tgtype))continue ;if (trigger->tgoldtable != NULL || trigger->tgnewtable != NULL)return trigger->tgname;return NULL;/* * Call a trigger function . * * trigdata : trigger descriptor . * tgindx : trigger ' s index in finfo and instr arrays . * finfo : array of cached trigger function call information . * instr : optional array of EXPLAIN ANALYZE instrumentation state . * per_tuple_context : memory context to execute the function in . * * Returns the tuple ( or NULL ) as returned by the function . static HeapTupleint tgindx,0 );/* * Protect against code paths that may fail to initialize transition table * info . /* * We cache fmgr lookup info , to avoid making the lookup again on each * call . if (finfo->fn_oid == InvalidOid)/* * If doing EXPLAIN ANALYZE , start charging time to this trigger . if (instr)/* * Do the function evaluation in the per - tuple memory context , so that * leaked memory will be reclaimed once per tuple . Note in particular that * any new tuple created by the trigger function will live till the end of * the tuple cycle . /* * Call the function , passing no arguments but setting a context . 0 ,true );/* * Trigger protocol allows function to return a null pointer , but NOT to * set the isnull result flag . if (fcinfo->isnull)"trigger function %u returned null value" ,/* * If doing EXPLAIN ANALYZE , stop charging time to this trigger , and count * one " tuple returned " ( really the number of firings ) . if (instr)1 );return (HeapTuple) DatumGetPointer(result);void int i;0 };if (trigdesc == NULL)return ;if (!trigdesc->trig_insert_before_statement)return ;/* no-op if we already fired BS triggers in this context */ if (before_stmt_triggers_fired(RelationGetRelid(relinfo->ri_RelationDesc),return ;for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (newtuple)"BEFORE STATEMENT trigger cannot return a value" )));void if (trigdesc && trigdesc->trig_insert_after_statement)false , NULL, NULL, NIL, NULL, transition_capture,false );bool bool should_free;0 };int i;for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (!newtuple)true , &should_free);if (newtuple == NULL)if (should_free)return false ; /* "do nothing" */ else if (newtuple != oldtuple)sc), newtuple);false );/* * After a tuple in a partition goes through a trigger , the user * could have changed the partition key enough that the tuple no * longer fits the partition . Verify that . if (trigger->tgisclone &&false ))"moving row to another partition during a BEFORE FOR EACH ROW trigger is not supported" ),"Before executing trigger \" %s\", the row was to be in partition \" %s.%s\"." ,if (should_free)/* signal tuple should be re-fetched if used */ return true ;void if (relinfo->ri_FdwRoutine && transition_capture &&"cannot collect transition tuples from child foreign tables" )));if ((trigdesc && trigdesc->trig_insert_after_row) ||true , NULL, slot,false );bool bool should_free;0 };int i;for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (!newtuple)true , &should_free);if (newtuple == NULL)if (should_free)return false ; /* "do nothing" */ else if (newtuple != oldtuple)false );if (should_free)/* signal tuple should be re-fetched if used */ return true ;void int i;0 };if (trigdesc == NULL)return ;if (!trigdesc->trig_delete_before_statement)return ;/* no-op if we already fired BS triggers in this context */ if (before_stmt_triggers_fired(RelationGetRelid(relinfo->ri_RelationDesc),return ;for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (newtuple)"BEFORE STATEMENT trigger cannot return a value" )));void if (trigdesc && trigdesc->trig_delete_after_statement)false , NULL, NULL, NIL, NULL, transition_capture,false );/* * Execute BEFORE ROW DELETE triggers . * * True indicates caller can proceed with the delete . False indicates caller * need to suppress the delete and additionally if requested , we need to pass * back the concurrently updated tuple if any . bool bool is_merge_delete)bool result = true ;0 };bool should_free = false ;int i;if (fdw_trigtuple == NULL)/* * Get a copy of the on - disk tuple we are planning to delete . In * general , if the tuple has been concurrently updated , we should * recheck it using EPQ . However , if this is a MERGE DELETE action , * we skip this EPQ recheck and leave it to the caller ( it must do * additional rechecking , and might end up executing a different * action entirely ) . if (!GetTupleForTrigger(estate, epqstate, relinfo, tupleid,return false ;/* * If the tuple was concurrently updated and the caller of this * function requested for the updated tuple , skip the trigger * execution . if (epqslot_candidate != NULL && epqslot != NULL)return false ;true , &should_free);else false );for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (newtuple == NULL)false ; /* tell caller to suppress delete */ break ;if (newtuple != trigtuple)if (should_free)return result;/* * Note : is_crosspart_update must be true if the DELETE is being performed * as part of a cross - partition update . void bool is_crosspart_update)if (relinfo->ri_FdwRoutine && transition_capture &&"cannot collect transition tuples from child foreign tables" )));if ((trigdesc && trigdesc->trig_delete_after_row) ||if (fdw_trigtuple == NULL)false ,else false );true , slot, NULL, NIL, NULL,bool 0 };int i;false );for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (rettuple == NULL)return false ; /* Delete was suppressed */ if (rettuple != trigtuple)return true ;void int i;0 };if (trigdesc == NULL)return ;if (!trigdesc->trig_update_before_statement)return ;/* no-op if we already fired BS triggers in this context */ if (before_stmt_triggers_fired(RelationGetRelid(relinfo->ri_RelationDesc),return ;/* statement-level triggers operate on the parent table */ for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (newtuple)"BEFORE STATEMENT trigger cannot return a value" )));void /* statement-level triggers operate on the parent table */ if (trigdesc && trigdesc->trig_update_after_statement)false , NULL, NULL, NIL,false );bool bool is_merge_update)bool should_free_trig = false ;bool should_free_new = false ;0 };int i;/* Determine lock mode to use */ if (fdw_trigtuple == NULL)/* * Get a copy of the on - disk tuple we are planning to update . In * general , if the tuple has been concurrently updated , we should * recheck it using EPQ . However , if this is a MERGE UPDATE action , * we skip this EPQ recheck and leave it to the caller ( it must do * additional rechecking , and might end up executing a different * action entirely ) . if (!GetTupleForTrigger(estate, epqstate, relinfo, tupleid,return false ; /* cancel the update action */ /* * In READ COMMITTED isolation level it ' s possible that target tuple * was changed due to concurrent update . In that case we have a raw * subplan output tuple in epqslot_candidate , and need to form a new * insertable tuple using ExecGetUpdateNewTuple to replace the one we * received in newslot . Neither we nor our callers have any further * interest in the passed - in tuple , so it ' s okay to overwrite newslot * with the newer data . if (epqslot_candidate != NULL)/* * Typically , the caller ' s newslot was also generated by * ExecGetUpdateNewTuple , so that epqslot_clean will be the same * slot and copying is not needed . But do the right thing if it * isn ' t . if (unlikely(newslot != epqslot_clean))/* * At this point newslot contains a virtual tuple that may * reference some fields of oldslot ' s tuple in some disk buffer . * If that tuple is in a different page than the original target * tuple , then our only pin on that buffer is oldslot ' s , and we ' re * about to release it . Hence we ' d better materialize newslot to * ensure it doesn ' t contain references into an unpinned buffer . * ( We ' d materialize it below anyway , but too late for safety . ) /* * Here we convert oldslot to a materialized slot holding trigtuple . * Neither slot passed to the triggers will hold any buffer pin . true , &should_free_trig);else /* Put the FDW-supplied tuple into oldslot to unify the cases */ false );for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (!newtuple)true , &should_free_new);if (newtuple == NULL)if (should_free_trig)if (should_free_new)return false ; /* "do nothing" */ else if (newtuple != oldtuple)sc), newtuple);false );/* * If the tuple returned by the trigger / being stored , is the old * row version , and the heap tuple passed to the trigger was * allocated locally , materialize the slot . Otherwise we might * free it while still referenced by the slot . if (should_free_trig && newtuple == trigtuple)if (should_free_new)/* signal tuple should be re-fetched if used */ if (should_free_trig)return true ;/* * Note : ' src_partinfo ' and ' dst_partinfo ' , when non - NULL , refer to the source * and destination partitions , respectively , of a cross - partition update of * the root partitioned table mentioned in the query , given by ' relinfo ' . * ' tupleid ' in that case refers to the ctid of the " old " tuple in the source * partition , and ' newslot ' contains the " new " tuple in the destination * partition . This interface allows to support the requirements of * ExecCrossPartitionUpdateForeignKey ( ) ; is_crosspart_update must be true in * that case . void bool is_crosspart_update)if (relinfo->ri_FdwRoutine && transition_capture &&"cannot collect transition tuples from child foreign tables" )));if ((trigdesc && trigdesc->trig_update_after_row) ||/* * Note : if the UPDATE is converted into a DELETE + INSERT as part of * update - partition - key operation , then this function is also called * separately for DELETE and INSERT to capture transition table rows . * In such case , either old tuple or new tuple can be NULL . if (fdw_trigtuple == NULL && ItemPointerIsValid(tupleid))false ,else if (fdw_trigtuple != NULL)false );else true ,bool bool should_free;0 };int i;false );for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (!newtuple)true , &should_free);if (newtuple == NULL)return false ; /* "do nothing" */ else if (newtuple != oldtuple)false );if (should_free)/* signal tuple should be re-fetched if used */ return true ;void int i;0 };if (trigdesc == NULL)return ;if (!trigdesc->trig_truncate_before_statement)return ;for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,continue ;if (newtuple)"BEFORE STATEMENT trigger cannot return a value" )));void if (trigdesc && trigdesc->trig_truncate_after_statement)false , NULL, NULL, NIL, NULL, NULL,false );/* * Fetch tuple into " oldslot " , dealing with locking and EPQ if necessary static bool bool do_epq_recheck,if (epqslot != NULL)int lockflags = 0 ;/* caller must pass an epqstate if EvalPlanQual is possible */ /* * lock tuple for update if (!IsolationUsesXactSnapshot())/* Let the caller know about the status of this operation */ if (tmresultp)if (tmfdp)switch (test)case TM_SelfModified:/* * The target tuple was already updated or deleted by the * current command , or by a later command in the current * transaction . We ignore the tuple in the former case , and * throw error in the latter case , for the same reasons * enumerated in ExecUpdate and ExecDelete in * nodeModifyTable . c . if (tmfd.cmax != estate->es_output_cid)"tuple to be updated was already modified by an operation triggered by the current command" ),"Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." )));/* treat it as deleted; do not process */ return false ;case TM_Ok:if (tmfd.traversed)/* * Recheck the tuple using EPQ , if requested . Otherwise , * just return that it was concurrently updated . if (do_epq_recheck)/* * If PlanQual failed for updated tuple - we must not * process this tuple ! if (TupIsNull(*epqslot))return false ;else if (tmresultp)return false ;break ;case TM_Updated:if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent update" )));"unexpected table_tuple_lock status: %u" , test);break ;case TM_Deleted:if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent delete" )));/* tuple was deleted */ return false ;case TM_Invisible:"attempted to lock invisible tuple" );break ;default :"unrecognized table_tuple_lock status: %u" , test);return false ; /* keep compiler quiet */ else /* * We expect the tuple to be present , thus very simple error handling * suffices . if (!table_tuple_fetch_row_version(relation, tid, SnapshotAny,"failed to fetch tuple for trigger" );return true ;/* * Is trigger enabled to fire ? static bool /* Check replication-role-dependent enable state */ if (SessionReplicationRole == SESSION_REPLICATION_ROLE_REPLICA)if (trigger->tgenabled == TRIGGER_FIRES_ON_ORIGIN ||return false ;else /* ORIGIN or LOCAL role */ if (trigger->tgenabled == TRIGGER_FIRES_ON_REPLICA ||return false ;/* * Check for column - specific trigger ( only possible for UPDATE , and in * fact we * must * ignore tgattr for other event types ) if (trigger->tgnattr > 0 && TRIGGER_FIRED_BY_UPDATE(event))int i;bool modified;false ;for (i = 0 ; i < trigger->tgnattr; i++)if (bms_is_member(trigger->tgattr[i] - FirstLowInvalidHeapAttributeNumber,true ;break ;if (!modified)return false ;/* Check for WHEN clause */ if (trigger->tgqual)int i;/* * trigger is an element of relinfo - > ri_TrigDesc - > triggers [ ] ; find the * matching element of relinfo - > ri_TrigWhenExprs [ ] /* * If first time through for this WHEN expression , build expression * nodetrees for it . Keep them in the per - query memory context so * they ' ll survive throughout the query . if (*predicate == NULL)VARNO);VARNO);/* Change references to OLD and NEW to INNER_VAR and OUTER_VAR */ 0 );0 );/* ExecPrepareQual wants implicit-AND form */ /* * We will use the EState ' s per - tuple context for evaluating WHEN * expressions ( creating it if it ' s not already there ) . /* * Finally evaluate the expression , making the old and / or new tuples * available as INNER_VAR / OUTER_VAR respectively . if (!ExecQual(*predicate, econtext))return false ;return true ;/* ---------- * After - trigger stuff * * The AfterTriggersData struct holds data about pending AFTER trigger events * during the current transaction tree . ( BEFORE triggers are fired * immediately so we don ' t need any persistent state about them . ) The struct * and most of its subsidiary data are kept in TopTransactionContext ; however * some data that can be discarded sooner appears in the CurTransactionContext * of the relevant subtransaction . Also , the individual event records are * kept in a separate sub - context of TopTransactionContext . This is done * mainly so that it ' s easy to tell from a memory context dump how much space * is being eaten by trigger events . * * Because the list of pending events can grow large , we go to some * considerable effort to minimize per - event memory consumption . The event * records are grouped into chunks and common data for similar events in the * same chunk is only stored once . * * XXX We need to be able to save the per - event data in a file if it grows too * large . * - - - - - - - - - - /* Per-trigger SET CONSTRAINT status */ typedef struct SetConstraintTriggerDatabool sct_tgisdeferred;typedef struct SetConstraintTriggerData *SetConstraintTrigger;/* * SET CONSTRAINT intra - transaction status . * * We make this a single palloc ' d object so it can be copied and freed easily . * * all_isset and all_isdeferred are used to keep track * of SET CONSTRAINTS ALL { DEFERRED , IMMEDIATE } . * * trigstates [ ] stores per - trigger tgisdeferred settings . typedef struct SetConstraintStateDatabool all_isset;bool all_isdeferred;int numstates; /* number of trigstates[] entries in use */ int numalloc; /* allocated size of trigstates[] */ typedef SetConstraintStateData *SetConstraintState;/* * Per - trigger - event data * * The actual per - event data , AfterTriggerEventData , includes DONE / IN_PROGRESS * status bits , up to two tuple CTIDs , and optionally two OIDs of partitions . * Each event record also has an associated AfterTriggerSharedData that is * shared across all instances of similar events within a " chunk " . * * For row - level triggers , we arrange not to waste storage on unneeded ctid * fields . Updates of regular tables use two ; inserts and deletes of regular * tables use one ; foreign tables always use zero and save the tuple ( s ) to a * tuplestore . AFTER_TRIGGER_FDW_FETCH directs AfterTriggerExecute ( ) to * retrieve a fresh tuple or pair of tuples from that tuplestore , while * AFTER_TRIGGER_FDW_REUSE directs it to use the most - recently - retrieved * tuple ( s ) . This permits storing tuples once regardless of the number of * row - level triggers on a foreign table . * * When updates on partitioned tables cause rows to move between partitions , * the OIDs of both partitions are stored too , so that the tuples can be * fetched ; such entries are marked AFTER_TRIGGER_CP_UPDATE ( for " cross - * partition update " ) . * * Note that we need triggers on foreign tables to be fired in exactly the * order they were queued , so that the tuples come out of the tuplestore in * the right order . To ensure that , we forbid deferrable ( constraint ) * triggers on foreign tables . This also ensures that such triggers do not * get deferred into outer trigger query levels , meaning that it ' s okay to * destroy the tuplestore at the end of the query level . * * Statement - level triggers always bear AFTER_TRIGGER_1CTID , though they * require no ctid field . We lack the flag bit space to neatly represent that * distinct case , and it seems unlikely to be worth much trouble . * * Note : ats_firing_id is initially zero and is set to something else when * AFTER_TRIGGER_IN_PROGRESS is set . It indicates which trigger firing * cycle the trigger will be fired in ( or was fired in , if DONE is set ) . * Although this is mutable state , we can keep it in AfterTriggerSharedData * because all instances of the same type of event in a given event list will * be fired at the same time , if they were queued between the same firing * cycles . So we need only ensure that ats_firing_id is zero when attaching * a new event to an existing AfterTriggerSharedData record . typedef uint32 TriggerFlags;#define AFTER_TRIGGER_OFFSET 0 x07FFFFFF /* must be low-order bits */ #define AFTER_TRIGGER_DONE 0 x80000000#define AFTER_TRIGGER_IN_PROGRESS 0 x40000000/* bits describing the size and tuple sources of this event */ #define AFTER_TRIGGER_FDW_REUSE 0 x00000000#define AFTER_TRIGGER_FDW_FETCH 0 x20000000#define AFTER_TRIGGER_1CTID 0 x10000000#define AFTER_TRIGGER_2CTID 0 x30000000#define AFTER_TRIGGER_CP_UPDATE 0 x08000000#define AFTER_TRIGGER_TUP_BITS 0 x38000000typedef struct AfterTriggerSharedData *AfterTriggerShared;typedef struct AfterTriggerSharedData/* event type indicator, see trigger.h */ /* the trigger's ID */ /* the relation it's on */ /* role to execute the trigger */ /* ID for firing cycle */ struct AfterTriggersTableData *ats_table; /* transition table access */ /* modified columns */ typedef struct AfterTriggerEventData *AfterTriggerEvent;typedef struct AfterTriggerEventData/* status bits and offset to shared data */ /* inserted, deleted, or old updated tuple */ /* new updated tuple */ /* * During a cross - partition update of a partitioned table , we also store * the OIDs of source and destination partitions that are needed to fetch * the old ( ctid1 ) and the new tuple ( ctid2 ) from , respectively . /* AfterTriggerEventData, minus ate_src_part, ate_dst_part */ typedef struct AfterTriggerEventDataNoOids/* AfterTriggerEventData, minus ate_*_part and ate_ctid2 */ typedef struct AfterTriggerEventDataOneCtid/* status bits and offset to shared data */ /* inserted, deleted, or old updated tuple */ /* AfterTriggerEventData, minus ate_*_part, ate_ctid1 and ate_ctid2 */ typedef struct AfterTriggerEventDataZeroCtids/* status bits and offset to shared data */ #define SizeofTriggerEvent(evt) \sizeof (AfterTriggerEventData) : \sizeof (AfterTriggerEventDataNoOids) : \sizeof (AfterTriggerEventDataOneCtid) : \sizeof (AfterTriggerEventDataZeroCtids))))#define GetTriggerSharedData(evt) \char *) (evt) + ((evt)->ate_flags & AFTER_TRIGGER_OFFSET)))/* * To avoid palloc overhead , we keep trigger events in arrays in successively - * larger chunks ( a slightly more sophisticated version of an expansible * array ) . The space between CHUNK_DATA_START and freeptr is occupied by * AfterTriggerEventData records ; the space between endfree and endptr is * occupied by AfterTriggerSharedData records . typedef struct AfterTriggerEventChunkstruct AfterTriggerEventChunk *next; /* list link */ char *freeptr; /* start of free space in chunk */ char *endfree; /* end of free space in chunk */ char *endptr; /* end of chunk */ /* event data follows here */ #define CHUNK_DATA_START(cptr) ((char *) (cptr) + MAXALIGN(sizeof (AfterTriggerEventChunk)))/* A list of events */ typedef struct AfterTriggerEventListchar *tailfree; /* freeptr of tail chunk */ /* Macros to help in iterating over a list of events */ #define for_each_chunk(cptr, evtlist) \for (cptr = (evtlist).head; cptr != NULL; cptr = cptr->next)#define for_each_event(eptr, cptr) \for (eptr = (AfterTriggerEvent) CHUNK_DATA_START(cptr); \char *) eptr < (cptr)->freeptr; \char *) eptr) + SizeofTriggerEvent(eptr)))/* Use this if no special per-chunk processing is needed */ #define for_each_event_chunk(eptr, cptr, evtlist) \/* Macros for iterating from a start point that might not be list start */ #define for_each_chunk_from(cptr) \for (; cptr != NULL; cptr = cptr->next)#define for_each_event_from(eptr, cptr) \for (; \char *) eptr < (cptr)->freeptr; \char *) eptr) + SizeofTriggerEvent(eptr)))/* * All per - transaction data for the AFTER TRIGGERS module . * * AfterTriggersData has the following fields : * * firing_counter is incremented for each call of afterTriggerInvokeEvents . * We mark firable events with the current firing cycle ' s ID so that we can * tell which ones to work on . This ensures sane behavior if a trigger * function chooses to do SET CONSTRAINTS : the inner SET CONSTRAINTS will * only fire those events that weren ' t already scheduled for firing . * * state keeps track of the transaction - local effects of SET CONSTRAINTS . * This is saved and restored across failed subtransactions . * * events is the current list of deferred events . This is global across * all subtransactions of the current transaction . In a subtransaction * abort , we know that the events added by the subtransaction are at the * end of the list , so it is relatively easy to discard them . The event * list chunks themselves are stored in event_cxt . * * query_depth is the current depth of nested AfterTriggerBeginQuery calls * ( - 1 when the stack is empty ) . * * query_stack [ query_depth ] is the per - query - level data , including these fields : * * events is a list of AFTER trigger events queued by the current query . * None of these are valid until the matching AfterTriggerEndQuery call * occurs . At that point we fire immediate - mode triggers , and append any * deferred events to the main events list . * * fdw_tuplestore is a tuplestore containing the foreign - table tuples * needed by events queued by the current query . ( Note : we use just one * tuplestore even though more than one foreign table might be involved . * This is okay because tuplestores don ' t really care what ' s in the tuples * they store ; but it ' s possible that someday it ' d break . ) * * tables is a List of AfterTriggersTableData structs for target tables * of the current query ( see below ) . * * maxquerydepth is just the allocated length of query_stack . * * trans_stack holds per - subtransaction data , including these fields : * * state is NULL or a pointer to a saved copy of the SET CONSTRAINTS * state data . Each subtransaction level that modifies that state first * saves a copy , which we use to restore the state if we abort . * * events is a copy of the events head / tail pointers , * which we use to restore those values during subtransaction abort . * * query_depth is the subtransaction - start - time value of query_depth , * which we similarly use to clean up at subtransaction abort . * * firing_counter is the subtransaction - start - time value of firing_counter . * We use this to recognize which deferred triggers were fired ( or marked * for firing ) within an aborted subtransaction . * * We use GetCurrentTransactionNestLevel ( ) to determine the correct array * index in trans_stack . maxtransdepth is the number of allocated entries in * trans_stack . ( By not keeping our own stack pointer , we can avoid trouble * in cases where errors during subxact abort cause multiple invocations * of AfterTriggerEndSubXact ( ) at the same nesting depth . ) * * We create an AfterTriggersTableData struct for each target table of the * current query , and each operation mode ( INSERT / UPDATE / DELETE ) , that has * either transition tables or statement - level triggers . This is used to * hold the relevant transition tables , as well as info tracking whether * we already queued the statement triggers . ( We use that info to prevent * firing the same statement triggers more than once per statement , or really * once per transition table set . ) These structs , along with the transition * table tuplestores , live in the ( sub ) transaction ' s CurTransactionContext . * That ' s sufficient lifespan because we don ' t allow transition tables to be * used by deferrable triggers , so they only need to survive until * AfterTriggerEndQuery . typedef struct AfterTriggersQueryData AfterTriggersQueryData;typedef struct AfterTriggersTransData AfterTriggersTransData;typedef struct AfterTriggersTableData AfterTriggersTableData;typedef struct AfterTriggersData/* next firing ID to assign */ /* the active S C state */ /* deferred-event list */ /* memory context for events, if any */ /* per-query-level data: */ /* array of structs shown below */ int query_depth; /* current index in above array */ int maxquerydepth; /* allocated len of above array */ /* per-subtransaction-level data: */ /* array of structs shown below */ int maxtransdepth; /* allocated len of above array */ struct AfterTriggersQueryData/* events pending from this query */ /* foreign tuples for said events */ /* list of AfterTriggersTableData, see below */ struct AfterTriggersTransData/* these fields are just for resetting at subtrans abort: */ /* saved S C state, or NULL if not yet saved */ /* saved list pointer */ int query_depth; /* saved query_depth */ /* saved firing_counter */ struct AfterTriggersTableData/* relid + cmdType form the lookup key for these structs: */ /* target table's OID */ /* event type, CMD_INSERT/UPDATE/DELETE */ bool closed; /* true when no longer OK to add tuples */ bool before_trig_done; /* did we already queue BS triggers? */ bool after_trig_done; /* did we already queue AS triggers? */ /* if so, saved list pointer */ /* "old" transition table for UPDATE/DELETE, if any */ /* "new" transition table for INSERT/UPDATE, if any */ /* for converting to tuplestore's format */ static AfterTriggersData afterTriggers;static void AfterTriggerExecute(EState *estate,static AfterTriggersTableData *GetAfterTriggersTableData(Oid relid,static TupleTableSlot *GetAfterTriggersStoreSlot(AfterTriggersTableData *table,static Tuplestorestate *GetAfterTriggersTransitionTable(int event,static void TransitionTableAddTuple(EState *estate,int event,static void AfterTriggerFreeQuery(AfterTriggersQueryData *qs);static SetConstraintState SetConstraintStateCreate(int numalloc);static SetConstraintState SetConstraintStateCopy(SetConstraintState origstate);static SetConstraintState SetConstraintStateAddItem(SetConstraintState state,bool tgisdeferred);static void cancel_prior_stmt_triggers(Oid relid, CmdType cmdType, int tgevent);/* * Get the FDW tuplestore for the current trigger query level , creating it * if necessary . static Tuplestorestate *void )if (ret == NULL)/* * Make the tuplestore valid until end of subtransaction . We really * only need it until AfterTriggerEndQuery ( ) . false , false , work_mem);return ret;/* ---------- * afterTriggerCheckState ( ) * * Returns true if the trigger event is actually in state DEFERRED . * - - - - - - - - - - static bool int i;/* * For not - deferrable triggers ( i . e . normal AFTER ROW triggers and * constraints declared NOT DEFERRABLE ) , the state is always false . if ((evtshared->ats_event & AFTER_TRIGGER_DEFERRABLE) == 0 )return false ;/* * If constraint state exists , SET CONSTRAINTS might have been executed * either for this trigger or for all triggers . if (state != NULL)/* Check for SET CONSTRAINTS for this specific trigger. */ for (i = 0 ; i < state->numstates; i++)if (state->trigstates[i].sct_tgoid == tgoid)return state->trigstates[i].sct_tgisdeferred;/* Check for SET CONSTRAINTS ALL. */ if (state->all_isset)return state->all_isdeferred;/* * Otherwise return the default state for the trigger . return ((evtshared->ats_event & AFTER_TRIGGER_INITDEFERRED) != 0 );/* ---------- * afterTriggerCopyBitmap ( ) * * Copy bitmap into AfterTriggerEvents memory context , which is where the after * trigger events are kept . * - - - - - - - - - - static Bitmapset *if (src == NULL)return NULL;return dst;/* ---------- * afterTriggerAddEvent ( ) * * Add a new trigger event to the specified queue . * The passed - in event data is copied . * - - - - - - - - - - static void sizeof (AfterTriggerSharedData);/* * If empty list or not enough room in the tail chunk , make a new chunk . * We assume here that a new shared record will always be needed . if (chunk == NULL ||/* Create event context if we didn't already */ if (afterTriggers.event_cxt == NULL)"AfterTriggerEvents" ,/* * Chunk size starts at 1 KB and is allowed to increase up to 1 MB . * These numbers are fairly arbitrary , though there is a hard limit at * AFTER_TRIGGER_OFFSET ; else we couldn ' t link event records to their * shared records using the available space in ate_flags . Another * constraint is that if the chunk size gets too huge , the search loop * below would get slow given a ( not too common ) usage pattern with * many distinct event types in a chunk . Therefore , we double the * preceding chunk size only if there weren ' t too many shared records * in the preceding chunk ; otherwise we halve it . This gives us some * ability to adapt to the actual usage pattern of the current query * while still having large chunk sizes in typical usage . All chunk * sizes used should be MAXALIGN multiples , to ensure that the shared * records will be aligned safely . #define MIN_CHUNK_SIZE 1024 #define MAX_CHUNK_SIZE (1024 *1024 )#if MAX_CHUNK_SIZE > (AFTER_TRIGGER_OFFSET+1 )#error MAX_CHUNK_SIZE must not exceed AFTER_TRIGGER_OFFSET#endif if (chunk == NULL)else /* preceding chunk size... */ char *) chunk;/* check number of shared records in preceding chunk */ if ((chunk->endptr - chunk->endfree) <=100 * sizeof (AfterTriggerSharedData)))2 ; /* okay, double it */ else 2 ; /* too many shared records */ char *) chunk + chunksize;if (events->tail == NULL)else /* events->tailfree is now out of sync, but we'll fix it below */ /* * Try to locate a matching shared - data record already in the chunk . If * none , make a new one . The search begins with the most recently added * record , since newer ones are most likely to match . for (newshared = (AfterTriggerShared) chunk->endfree;char *) newshared < chunk->endptr;/* compare fields roughly by probability of them being different */ if (newshared->ats_tgoid == evtshared->ats_tgoid &&0 &&break ;if ((char *) newshared >= chunk->endptr)1 ;/* now we must make a suitably-long-lived copy of the bitmap */ 0 ; /* just to be sure */ char *) newshared;/* Insert the data */ /* ... and link the new event to its shared record */ char *) newshared - (char *) newevent;/* ---------- * afterTriggerFreeEventList ( ) * * Free all the event storage in the given list . * - - - - - - - - - - static void while ((chunk = events->head) != NULL)/* ---------- * afterTriggerRestoreEventList ( ) * * Restore an event list to its prior length , removing all the events * added since it had the value old_events . * - - - - - - - - - - static void const AfterTriggerEventList *old_events)if (old_events->tail == NULL)/* restoring to a completely empty state, so free everything */ else /* free any chunks after the last one we want to keep */ for (chunk = events->tail->next; chunk != NULL; chunk = next_chunk)/* and clean up the tail chunk to be the right length */ /* * We don ' t make any effort to remove now - unused shared data records . * They might still be useful , anyway . /* ---------- * afterTriggerDeleteHeadEventChunk ( ) * * Remove the first chunk of events from the query level ' s event list . * Keep any event list pointers elsewhere in the query level ' s data * structures in sync . * - - - - - - - - - - static void /* * First , update any pointers in the per - table data , so that they won ' t be * dangling . Resetting obsoleted pointers to NULL will make * cancel_prior_stmt_triggers start from the list head , which is fine . if (table->after_trig_done &&/* Now we can flush the head chunk */ /* ---------- * AfterTriggerExecute ( ) * * Fetch the required tuples back from the heap and fire one * single trigger function . * * Frequently , this will be fired many times in a row for triggers of * a single relation . Therefore , we cache the open relation and provide * fmgr lookup cache space at the caller level . ( For triggers fired at * the end of a query , we can even piggyback on the executor ' s state . ) * * When fired for a cross - partition update of a partitioned table , the old * tuple is fetched using ' src_relInfo ' ( the source leaf partition ) and * the new tuple using ' dst_relInfo ' ( the destination leaf partition ) , though * both are converted into the root partitioned table ' s format before passing * to the trigger function . * * event : event currently being fired . * relInfo : result relation for event . * src_relInfo : source partition of a cross - partition update * dst_relInfo : its destination partition * trigdesc : working copy of rel ' s trigger info . * finfo : array of fmgr lookup cache entries ( one per trigger in trigdesc ) . * instr : array of EXPLAIN ANALYZE instrumentation nodes ( one per trigger ) , * or NULL if no instrumentation is wanted . * per_tuple_context : memory context to call trigger function in . * trig_tuple_slot1 : scratch slot for tg_trigtuple ( foreign tables only ) * trig_tuple_slot2 : scratch slot for tg_newtuple ( foreign tables only ) * - - - - - - - - - - static void 0 };int save_sec_context;int tgindx;bool should_free_trig = false ;bool should_free_new = false ;/* * Locate trigger in trigdesc . It might not be present , and in fact the * trigdesc could be NULL , if the trigger was dropped since the event was * queued . In that case , silently do nothing . if (trigdesc == NULL)return ;for (tgindx = 0 ; tgindx < trigdesc->numtriggers; tgindx++)if (trigdesc->triggers[tgindx].tgoid == tgoid)break ;if (LocTriggerData.tg_trigger == NULL)return ;/* * If doing EXPLAIN ANALYZE , start charging time to this trigger . We want * to include time spent re - fetching tuples in the trigger cost . if (instr)/* * Fetch the required tuple ( s ) . switch (event->ate_flags & AFTER_TRIGGER_TUP_BITS)case AFTER_TRIGGER_FDW_FETCH:if (!tuplestore_gettupleslot(fdw_tuplestore, true , false ,"failed to fetch tuple1 for AFTER trigger" );if ((evtshared->ats_event & TRIGGER_EVENT_OPMASK) ==true , false ,"failed to fetch tuple2 for AFTER trigger" );/* fall through */ case AFTER_TRIGGER_FDW_REUSE:/* * Store tuple in the slot so that tg_trigtuple does not reference * tuplestore memory . ( It is formally possible for the trigger * function to queue trigger events that add to the same * tuplestore , which can push other tuples out of memory . ) The * distinction is academic , because we start with a minimal tuple * that is stored as a heap tuple , constructed in different memory * context , in the slot anyway . true , &should_free_trig);if ((evtshared->ats_event & TRIGGER_EVENT_OPMASK) ==true , &should_free_new);else break ;default :if (ItemPointerIsValid(&(event->ate_ctid1)))if (!table_tuple_fetch_row_version(src_rel,"failed to fetch tuple1 for AFTER trigger" );/* * Store the tuple fetched from the source partition into the * target ( root partitioned ) table slot , converting if needed . if (src_relInfo != relInfo)if (map)else else false , &should_free_trig);else /* don't touch ctid2 if not there */ if (((event->ate_flags & AFTER_TRIGGER_TUP_BITS) == AFTER_TRIGGER_2CTID ||if (!table_tuple_fetch_row_version(dst_rel,"failed to fetch tuple2 for AFTER trigger" );/* * Store the tuple fetched from the destination partition into * the target ( root partitioned ) table slot , converting if * needed . if (dst_relInfo != relInfo)if (map)else else false , &should_free_new);else /* * Set up the tuplestore information to let the trigger have access to * transition tables . When we first make a transition table available to * a trigger , mark it " closed " so that it cannot change anymore . If any * additional events of the same type get queued in the current trigger * query level , they ' ll go into new transition tables . if (evtshared->ats_table)if (LocTriggerData.tg_trigger->tgoldtable)true ;if (LocTriggerData.tg_trigger->tgnewtable)true ;/* * Setup the remaining trigger information if (TRIGGER_FOR_UPDATE(LocTriggerData.tg_trigger->tgtype))/* * If necessary , become the role that was active when the trigger got * queued . Note that the role might have been dropped since the trigger * was queued , but if that is a problem , we will get an error later . * Checking here would still leave a race condition . if (save_rolid != evtshared->ats_rolid)/* * Call the trigger and throw away any possibly returned updated tuple . * ( Don ' t let ExecCallTriggerFunc measure EXPLAIN time . ) if (rettuple != NULL &&/* Restore the current role if necessary */ if (save_rolid != evtshared->ats_rolid)/* * Release resources if (should_free_trig)if (should_free_new)/* don't clear slots' contents if foreign table */ if (trig_tuple_slot1 == NULL)if (LocTriggerData.tg_trigslot)if (LocTriggerData.tg_newslot)/* * If doing EXPLAIN ANALYZE , stop charging time to this trigger , and count * one " tuple returned " ( really the number of firings ) . if (instr)1 );/* * afterTriggerMarkEvents ( ) * * Scan the given event list for not yet invoked events . Mark the ones * that can be invoked now with the current firing ID . * * If move_list isn ' t NULL , events that are not to be invoked now are * transferred to move_list . * * When immediate_only is true , do not invoke currently - deferred triggers . * ( This will be false only at main transaction exit . ) * * Returns true if any invokable events were found . static bool bool immediate_only)bool found = false ;bool deferred_found = false ;bool defer_it = false ;if (!(event->ate_flags &/* * This trigger hasn ' t been called or scheduled yet . Check if we * should call it now . if (immediate_only && afterTriggerCheckState(evtshared))true ;else /* * Mark it as to be fired in this firing cycle . true ;/* * If it ' s deferred , move it to move_list , if requested . if (defer_it && move_list != NULL)true ;/* add it to move_list */ /* mark original copy "done" so we don't do it again */ /* * We could allow deferred triggers if , before the end of the * security - restricted operation , we were to verify that a SET CONSTRAINTS * . . . IMMEDIATE has fired all such triggers . For now , don ' t bother . if (deferred_found && InSecurityRestrictedOperation())"cannot fire deferred trigger within security-restricted operation" )));return found;/* * afterTriggerInvokeEvents ( ) * * Scan the given event list for events that are marked as to be fired * in the current firing cycle , and fire them . * * If estate isn ' t NULL , we use its result relation info to avoid repeated * openings and closing of trigger target relations . If it is NULL , we * make one locally to cache the info in case there are multiple trigger * events per rel . * * When delete_ok is true , it ' s safe to delete fully - processed events . * ( We are not very tense about that : we simply reset a chunk to be empty * if all its events got fired . The objective here is just to avoid useless * rescanning of events when a trigger queues new events during transaction * end , so it ' s not necessary to worry much about the case where only * some events are fired . ) * * Returns true if no unfired events remain in the list ( this allows us * to avoid repeating afterTriggerMarkEvents ) . static bool bool delete_ok)bool all_fired = true ;bool local_estate = false ;/* Make a local EState if need be */ if (estate == NULL)true ;/* Make a per-tuple memory context for trigger function calls */ "AfterTriggerTupleContext" ,bool all_fired_in_chunk = true ;/* * Is it one for me to fire ? if ((event->ate_flags & AFTER_TRIGGER_IN_PROGRESS) &&/* * So let ' s fire it . . . but first , find the correct relation if * this is not the same relation as before . if (rel == NULL || RelationGetRelid(rel) != evtshared->ats_relid)/* Catch calls with insufficient relcache refcounting */ /* caution: trigdesc could be NULL here */ if (slot1 != NULL)if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)/* * Look up source and destination partition result rels of a * cross - partition update event . if ((event->ate_flags & AFTER_TRIGGER_TUP_BITS) ==else /* * Fire it . Note that the AFTER_TRIGGER_IN_PROGRESS flag is * still set , so recursive examinations of the event list * won ' t try to re - fire it . /* * Mark the event as done . else if (!(event->ate_flags & AFTER_TRIGGER_DONE))/* something remains to be done */ false ;/* Clear the chunk if delete_ok and nothing left of interest */ if (delete_ok && all_fired_in_chunk)/* * If it ' s last chunk , must sync event list ' s tailfree too . Note * that delete_ok must NOT be passed as true if there could be * additional AfterTriggerEventList values pointing at this event * list , since we ' d fail to fix their copies of tailfree . if (chunk == events->tail)if (slot1 != NULL)/* Release working resources */ if (local_estate)false );return all_fired;/* * GetAfterTriggersTableData * * Find or create an AfterTriggersTableData struct for the specified * trigger event ( relation + operation type ) . Ignore existing structs * marked " closed " ; we don ' t want to put any additional tuples into them , * nor change their stmt - triggers - fired state . * * Note : the AfterTriggersTableData list is allocated in the current * ( sub ) transaction ' s CurTransactionContext . This is OK because * we don ' t need it to live past AfterTriggerEndQuery . static AfterTriggersTableData */* At this level, cmdType should not be, eg, CMD_MERGE */ /* Caller should have ensured query_depth is OK. */ 0 &&if (table->relid == relid && table->cmdType == cmdType &&return table;sizeof (AfterTriggersTableData));return table;/* * Returns a TupleTableSlot suitable for holding the tuples to be put * into AfterTriggersTableData ' s transition table tuplestores . static TupleTableSlot */* Create it if not already done. */ if (!table->storeslot)/* * We need this slot only until AfterTriggerEndQuery , but making it * last till end - of - subxact is good enough . It ' ll be freed by * AfterTriggerFreeQuery ( ) . However , the passed - in tupdesc might have * a different lifespan , so we ' d better make a copy of that . return table->storeslot;/* * MakeTransitionCaptureState * * Make a TransitionCaptureState object for the given TriggerDesc , target * relation , and operation type . The TCS object holds all the state needed * to decide whether to capture tuples in transition tables . * * If there are no triggers in ' trigdesc ' that request relevant transition * tables , then return NULL . * * The resulting object can be passed to the ExecAR * functions . When * dealing with child tables , the caller can set tcs_original_insert_tuple * to avoid having to reconstruct the original tuple in the root table ' s * format . * * Note that we copy the flags from a parent table into this struct ( rather * than subsequently using the relation ' s TriggerDesc directly ) so that we can * use it to control collection of transition tuples from child tables . * * Per SQL spec , all operations of the same kind ( INSERT / UPDATE / DELETE ) * on the same table during one query should share one transition table . * Therefore , the Tuplestores are owned by an AfterTriggersTableData struct * looked up using the table OID + CmdType , and are merely referenced by * the TransitionCaptureState objects we hand out to callers . bool need_old_upd,if (trigdesc == NULL)return NULL;/* Detect which table(s) we need. */ switch (cmdType)case CMD_INSERT:false ;break ;case CMD_UPDATE:false ;break ;case CMD_DELETE:false ;break ;case CMD_MERGE:break ;default :"unexpected CmdType: %d" , (int ) cmdType);/* keep compiler quiet */ false ;break ;if (!need_old_upd && !need_new_upd && !need_new_ins && !need_old_del)return NULL;/* Check state, like AfterTriggerSaveEvent. */ if (afterTriggers.query_depth < 0 )"MakeTransitionCaptureState() called outside of query" );/* Be sure we have enough space to record events at this query depth. */ if (afterTriggers.query_depth >= afterTriggers.maxquerydepth)/* * Find or create AfterTriggersTableData struct ( s ) to hold the * tuplestore ( s ) . If there ' s a matching struct but it ' s marked closed , * ignore it ; we need a newer one . * * Note : MERGE must use the same AfterTriggersTableData structs as INSERT , * UPDATE , and DELETE , so that any MERGE ' d tuples are added to the same * tuplestores as tuples from any INSERT , UPDATE , or DELETE commands * running in the same top - level command ( e . g . , in a writable CTE ) . * * Note : the AfterTriggersTableData list , as well as the tuplestores , are * allocated in the current ( sub ) transaction ' s CurTransactionContext , and * the tuplestores are managed by the ( sub ) transaction ' s resource owner . * This is sufficient lifespan because we do not allow triggers using * transition tables to be deferrable ; they will be fired during * AfterTriggerEndQuery , after which it ' s okay to delete the data . if (need_new_ins)else if (need_old_upd || need_new_upd)else if (need_old_del)else /* Now create required tuplestore(s), if we don't have them already. */ if (need_old_upd && upd_table->old_tuplestore == NULL)false , false , work_mem);if (need_new_upd && upd_table->new_tuplestore == NULL)false , false , work_mem);if (need_old_del && del_table->old_tuplestore == NULL)false , false , work_mem);if (need_new_ins && ins_table->new_tuplestore == NULL)false , false , work_mem);/* Now build the TransitionCaptureState struct, in caller's context */ sizeof (TransitionCaptureState));return state;/* ---------- * AfterTriggerBeginXact ( ) * * Called at transaction start ( either BEGIN or implicit for single * statement outside of transaction block ) . * - - - - - - - - - - void void )/* * Initialize after - trigger state structure to empty 1 ; /* mustn't be 0 */ 1 ;/* * Verify that there is no leftover state remaining . If these assertions * trip , it means that AfterTriggerEndXact wasn ' t called or didn ' t clean * up properly . 0 );0 );/* ---------- * AfterTriggerBeginQuery ( ) * * Called just before we start processing a single query within a * transaction ( or subtransaction ) . Most of the real work gets deferred * until somebody actually tries to queue a trigger event . * - - - - - - - - - - void void )/* Increase the query stack depth */ /* ---------- * AfterTriggerEndQuery ( ) * * Called after one query has been completely processed . At this time * we invoke all AFTER IMMEDIATE trigger events queued by the query , and * transfer deferred trigger events to the global deferred - trigger list . * * Note that this must be called BEFORE closing down the executor * with ExecutorEnd , because we make use of the EState ' s info about * target relations . Normally it is called from ExecutorFinish . * - - - - - - - - - - void /* Must be inside a query, too */ 0 );/* * If we never even got as far as initializing the event stack , there * certainly won ' t be any events , so exit quickly . if (afterTriggers.query_depth >= afterTriggers.maxquerydepth)return ;/* * Process all immediate - mode triggers queued by the query , and move the * deferred ones to the main list of deferred events . * * Notice that we decide which ones will be fired , and put the deferred * ones on the main list , before anything is actually fired . This ensures * reasonably sane behavior if a trigger function does SET CONSTRAINTS . . . * IMMEDIATE : all events we have decided to defer will be available for it * to fire . * * We loop in case a trigger queues more events at the same query level . * Ordinary trigger functions , including all PL / pgSQL trigger functions , * will instead fire any triggers in a dedicated query level . Foreign key * enforcement triggers do add to the current query level , thanks to their * passing fire_triggers = false to SPI_execute_snapshot ( ) . Other * C - language triggers might do likewise . * * If we find no firable events , we don ' t have to increment * firing_counter . for (;;)if (afterTriggerMarkEvents(&qs->events, &afterTriggers.events, true ))if (afterTriggerInvokeEvents(&qs->events, firing_id, estate, false ))break ; /* all fired */ /* * Firing a trigger could result in query_stack being repalloc ' d , * so we must recalculate qs after each afterTriggerInvokeEvents * call . Furthermore , it ' s unsafe to pass delete_ok = true here , * because that could cause afterTriggerInvokeEvents to try to * access qs - > events after the stack has been repalloc ' d . /* * We ' ll need to scan the events list again . To reduce the cost * of doing so , get rid of completely - fired chunks . We know that * all events were marked IN_PROGRESS or DONE at the conclusion of * afterTriggerMarkEvents , so any still - interesting events must * have been added after that , and so must be in the chunk that * was then the tail chunk , or in later chunks . So , zap all * chunks before oldtail . This is approximately the same set of * events we would have gotten rid of by passing delete_ok = true . while (qs->events.head != oldtail)else break ;/* Release query-level-local storage, including tuplestores if any */ /* * AfterTriggerFreeQuery * Release subsidiary storage for a trigger query level . * This includes closing down tuplestores . * Note : it ' s important for this to be safe if interrupted by an error * and then called again for the same query level . static void /* Drop the trigger events */ /* Drop FDW tuplestore if any */ if (ts)/* Release per-table subsidiary storage */ if (ts)if (ts)if (table->storeslot)/* * Now free the AfterTriggersTableData structs and list cells . Reset list * pointer first ; if list_free_deep somehow gets an error , better to leak * that storage than have an infinite loop . /* ---------- * AfterTriggerFireDeferred ( ) * * Called just before the current transaction is committed . At this * time we invoke all pending DEFERRED triggers . * * It is possible for other modules to queue additional deferred triggers * during pre - commit processing ; therefore xact . c may have to call this * multiple times . * - - - - - - - - - - void void )bool snap_pushed = false ;/* Must not be inside a query */ 1 );/* * If there are any triggers to fire , make sure we have set a snapshot for * them to use . ( Since PortalRunUtility doesn ' t set a snap for COMMIT , we * can ' t assume ActiveSnapshot is valid on entry . ) if (events->head != NULL)true ;/* * Run all the remaining triggers . Loop until they are all gone , in case * some trigger queues more for us to do . while (afterTriggerMarkEvents(events, NULL, false ))if (afterTriggerInvokeEvents(events, firing_id, NULL, true ))break ; /* all fired */ /* * We don ' t bother freeing the event list , since it will go away anyway * ( and more efficiently than via pfree ) in AfterTriggerEndXact . if (snap_pushed)/* ---------- * AfterTriggerEndXact ( ) * * The current transaction is finishing . * * Any unfired triggers are canceled so we simply throw * away anything we know . * * Note : it is possible for this to be called repeatedly in case of * error during transaction abort ; therefore , do not complain if * already closed down . * - - - - - - - - - - void bool isCommit)/* * Forget the pending - events list . * * Since all the info is in TopTransactionContext or children thereof , we * don ' t really need to do anything to reclaim memory . However , the * pending - events list could be large , and so it ' s useful to discard it as * soon as possible - - - especially if we are aborting because we ran out * of memory for the list ! if (afterTriggers.event_cxt)/* * Forget any subtransaction state as well . Since this can ' t be very * large , we let the eventual reset of TopTransactionContext free the * memory instead of doing it here . 0 ;/* * Forget the query stack and constraint - related state information . As * with the subtransaction state information , we don ' t bother freeing the * memory here . 0 ;/* No more afterTriggers manipulation until next transaction starts. */ 1 ;/* * AfterTriggerBeginSubXact ( ) * * Start a subtransaction . void void )int my_level = GetCurrentTransactionNestLevel();/* * Allocate more space in the trans_stack if needed . ( Note : because the * minimum nest level of a subtransaction is 2 , we waste the first couple * entries of the array ; not worth the notational effort to avoid it . ) while (my_level >= afterTriggers.maxtransdepth)if (afterTriggers.maxtransdepth == 0 )/* Arbitrarily initialize for max of 8 subtransaction levels */ 8 * sizeof (AfterTriggersTransData));8 ;else /* repalloc will keep the stack in the same context */ int new_alloc = afterTriggers.maxtransdepth * 2 ;sizeof (AfterTriggersTransData));/* * Push the current information into the stack . The SET CONSTRAINTS state * is not saved until / unless changed . Likewise , we don ' t make a * per - subtransaction event context until needed . /* * AfterTriggerEndSubXact ( ) * * The current subtransaction is ending . void bool isCommit)int my_level = GetCurrentTransactionNestLevel();/* * Pop the prior state if needed . if (isCommit)/* If we saved a prior state, we don't need it anymore */ if (state != NULL)/* this avoids double pfree if error later: */ else /* * Aborting . It is possible subxact start failed before calling * AfterTriggerBeginSubXact , in which case we mustn ' t risk touching * trans_stack levels that aren ' t there . if (my_level >= afterTriggers.maxtransdepth)return ;/* * Release query - level storage for queries being aborted , and restore * query_depth to its pre - subxact value . This assumes that a * subtransaction will not add events to query levels started in a * earlier transaction state . while (afterTriggers.query_depth > afterTriggers.trans_stack[my_level].query_depth)if (afterTriggers.query_depth < afterTriggers.maxquerydepth)/* * Restore the global deferred - event list to its former length , * discarding any events queued by the subxact . /* * Restore the trigger state . If the saved state is NULL , then this * subxact didn ' t save it , so it doesn ' t need restoring . if (state != NULL)/* this avoids double pfree if error later: */ /* * Scan for any remaining deferred events that were marked DONE or IN * PROGRESS by this subxact or a child , and un - mark them . We can * recognize such events because they have a firing ID greater than or * equal to the firing_counter value we saved at subtransaction start . * ( This essentially assumes that the current subxact includes all * subxacts started after it . ) if (event->ate_flags &if (evtshared->ats_firing_id >= subxact_firing_id)/* * Get the transition table for the given event and depending on whether we are * processing the old or the new tuple . static Tuplestorestate *int event,bool delete_old_table = transition_capture->tcs_delete_old_table;bool update_old_table = transition_capture->tcs_update_old_table;bool update_new_table = transition_capture->tcs_update_new_table;bool insert_new_table = transition_capture->tcs_insert_new_table;/* * For INSERT events NEW should be non - NULL , for DELETE events OLD should * be non - NULL , whereas for UPDATE events normally both OLD and NEW are * non - NULL . But for UPDATE events fired for capturing transition tuples * during UPDATE partition - key row movement , OLD is NULL when the event is * for a row being inserted , whereas NEW is NULL when the event is for a * row being deleted . if (!TupIsNull(oldslot))if (event == TRIGGER_EVENT_DELETE && delete_old_table)else if (event == TRIGGER_EVENT_UPDATE && update_old_table)else if (!TupIsNull(newslot))if (event == TRIGGER_EVENT_INSERT && insert_new_table)else if (event == TRIGGER_EVENT_UPDATE && update_new_table)return tuplestore;/* * Add the given heap tuple to the given tuplestore , applying the conversion * map if necessary . * * If original_insert_tuple is given , we can add that tuple without conversion . static void int event,/* * Nothing needs to be done if we don ' t have a tuplestore . if (tuplestore == NULL)return ;if (original_insert_tuple)else if ((map = ExecGetChildToRootMap(relinfo)) != NULL)switch (event)case TRIGGER_EVENT_INSERT:break ;case TRIGGER_EVENT_UPDATE:break ;case TRIGGER_EVENT_DELETE:break ;default :"invalid after-trigger event code: %d" , event);/* keep compiler quiet */ break ;else /* ---------- * AfterTriggerEnlargeQueryState ( ) * * Prepare the necessary state so that we can record AFTER trigger events * queued by a query . It is allowed to have nested queries within a * ( sub ) transaction , so we need to have separate state for each query * nesting level . * - - - - - - - - - - static void void )int init_depth = afterTriggers.maxquerydepth;if (afterTriggers.maxquerydepth == 0 )int new_alloc = Max(afterTriggers.query_depth + 1 , 8 );sizeof (AfterTriggersQueryData));else /* repalloc will keep the stack in the same context */ int old_alloc = afterTriggers.maxquerydepth;int new_alloc = Max(afterTriggers.query_depth + 1 ,2 );sizeof (AfterTriggersQueryData));/* Initialize new array entries to empty */ while (init_depth < afterTriggers.maxquerydepth)/* * Create an empty SetConstraintState with room for numalloc trigstates static SetConstraintStateint numalloc)/* Behave sanely with numalloc == 0 */ if (numalloc <= 0 )1 ;/* * We assume that zeroing will correctly initialize the state values . sizeof (SetConstraintTriggerData));return state;/* * Copy a SetConstraintState static SetConstraintStatesizeof (SetConstraintTriggerData));return state;/* * Add a per - trigger item to a SetConstraintState . Returns possibly - changed * pointer to the state object ( it will change if we have to repalloc ) . static SetConstraintStatebool tgisdeferred)if (state->numstates >= state->numalloc)int newalloc = state->numalloc * 2 ;8 ); /* in case original has size 0 */ sizeof (SetConstraintTriggerData));return state;/* ---------- * AfterTriggerSetState ( ) * * Execute the SET CONSTRAINTS . . . utility command . * - - - - - - - - - - void int my_level = GetCurrentTransactionNestLevel();/* If we haven't already done so, initialize our state. */ if (afterTriggers.state == NULL)8 );/* * If in a subtransaction , and we didn ' t save the current state already , * save it so it can be restored if the subtransaction aborts . if (my_level > 1 &&/* * Handle SET CONSTRAINTS ALL . . . if (stmt->constraints == NIL)/* * Forget any previous SET CONSTRAINTS commands in this transaction . 0 ;/* * Set the per - transaction ALL state to known . true ;else /* * Handle SET CONSTRAINTS constraint - name [ , . . . ] * * First , identify all the named constraints and make a list of their * OIDs . Since , unlike the SQL spec , we allow multiple constraints of * the same name within a schema , the specifications are not * necessarily unique . Our strategy is to target all matching * constraints within the first search - path schema that has any * matches , but disregard matches in schemas beyond the first match . * ( This is a bit odd but it ' s the historical behavior . ) * * A constraint in a partitioned table may have corresponding * constraints in the partitions . Grab those too . bool found;if (constraint->catalogname)if (strcmp(constraint->catalogname, get_database_name(MyDatabaseId)) != 0 )"cross-database references are not implemented: \" %s.%s.%s\"" ,/* * If we ' re given the schema name with the constraint , look only * in that schema . If given a bare constraint name , use the * search path to find the first matching constraint . if (constraint->schemaname)false );else true );false ;2 ];0 ],1 ],true , NULL, 2 , skey);while (HeapTupleIsValid(tup = systable_getnext(conscan)))if (con->condeferrable)else if (stmt->deferred)"constraint \" %s\" is not deferrable" ,true ;/* * Once we ' ve found a matching constraint we do not search * later parts of the search path . if (found)break ;/* * Not found ? if (!found)"constraint \" %s\" does not exist" ,/* * Scan for any possible descendants of the constraints . We append * whatever we find to the same list that we ' re scanning ; this has the * effect that we create new scans for those , too , so if there are * further descendents , we ' ll also catch them . true , NULL, 1 , &key);while (HeapTupleIsValid(tuple = systable_getnext(scan)))/* * Now , locate the trigger ( s ) implementing each of these constraints , * and make a list of their OIDs . true ,1 , &skey);while (HeapTupleIsValid(htup = systable_getnext(tgscan)))/* * Silently skip triggers that are marked as non - deferrable in * pg_trigger . This is not an error condition , since a * deferrable RI constraint may have some non - deferrable * actions . if (pg_trigger->tgdeferrable)/* * Now we can set the trigger states of individual triggers for this * xact . bool found = false ;int i;for (i = 0 ; i < state->numstates; i++)if (state->trigstates[i].sct_tgoid == tgoid)true ;break ;if (!found)/* * SQL99 requires that when a constraint is set to IMMEDIATE , any deferred * checks against that constraint must be made when the SET CONSTRAINTS * command is executed - - i . e . the effects of the SET CONSTRAINTS command * apply retroactively . We ' ve updated the constraints state , so scan the * list of previously deferred events to fire any that have now become * immediate . * * Obviously , if this was SET . . . DEFERRED then it can ' t have converted * any unfired events to immediate , so we need do nothing in that case . if (!stmt->deferred)bool snapshot_set = false ;while (afterTriggerMarkEvents(events, NULL, true ))/* * Make sure a snapshot has been established in case trigger * functions need one . Note that we avoid setting a snapshot if * we don ' t find at least one trigger that has to be fired now . * This is so that BEGIN ; SET CONSTRAINTS . . . ; SET TRANSACTION * ISOLATION LEVEL SERIALIZABLE ; . . . works properly . ( If we are * at the start of a transaction it ' s not possible for any trigger * events to be queued yet . ) if (!snapshot_set)true ;/* * We can delete fired events if we are at top transaction level , * but we ' d better not if inside a subtransaction , since the * subtransaction could later get rolled back . if (afterTriggerInvokeEvents(events, firing_id, NULL,break ; /* all fired */ if (snapshot_set)/* ---------- * AfterTriggerPendingOnRel ( ) * Test to see if there are any pending after - trigger events for rel . * * This is used by TRUNCATE , CLUSTER , ALTER TABLE , etc to detect whether * it is unsafe to perform major surgery on a relation . Note that only * local pending events are examined . We assume that having exclusive lock * on a rel guarantees there are no unserviced events in other backends - - - * but having a lock does not prevent there being such events in our own . * * In some scenarios it ' d be reasonable to remove pending events ( more * specifically , mark them DONE by the current subxact ) but without a lot * of knowledge of the trigger semantics we can ' t do this in general . * - - - - - - - - - - bool int depth;/* Scan queued events */ /* * We can ignore completed events . ( Even if a DONE flag is rolled * back by subxact abort , it ' s OK because the effects of the TRUNCATE * or whatever must get rolled back too . ) if (event->ate_flags & AFTER_TRIGGER_DONE)continue ;if (evtshared->ats_relid == relid)return true ;/* * Also scan events queued by incomplete queries . This could only matter * if TRUNCATE / etc is executed by a function or trigger within an updating * query on the same relation , which is pretty perverse , but let ' s check . for (depth = 0 ; depth <= afterTriggers.query_depth && depth < afterTriggers.maxquerydepth; depth++)if (event->ate_flags & AFTER_TRIGGER_DONE)continue ;if (evtshared->ats_relid == relid)return true ;return false ;/* ---------- * AfterTriggerSaveEvent ( ) * * Called by ExecA [ RS ] . . . Triggers ( ) to queue up the triggers that should * be fired for an event . * * NOTE : this is called whenever there are any triggers associated with * the event ( even if they are disabled ) . This function decides which * triggers actually need to be queued . It is also called after each row , * even if there are no triggers for that event , if there are any AFTER * STATEMENT triggers for the statement which use transition tables , so that * the transition tuplestores can be built . Furthermore , if the transition * capture is happening for UPDATEd rows being moved to another partition due * to the partition - key being changed , then this function is called once when * the row is deleted ( to capture OLD row ) , and once when the row is inserted * into another partition ( to capture NEW row ) . This is done separately because * DELETE and INSERT happen on different tables . * * Transition tuplestores are built now , rather than when events are pulled * off of the queue because AFTER ROW triggers are allowed to select from the * transition tables for the statement . * * This contains special support to queue the update events for the case where * a partitioned table undergoing a cross - partition update may have foreign * keys pointing into it . Normally , a partitioned table ' s row triggers are * not fired because the leaf partition ( s ) which are modified as a result of * the operation on the partitioned table contain the same triggers which are * fired instead . But that general scheme can cause problematic behavior with * foreign key triggers during cross - partition updates , which are implemented * as DELETE on the source partition followed by INSERT into the destination * partition . Specifically , firing DELETE triggers would lead to the wrong * foreign key action to be enforced considering that the original command is * UPDATE ; in this case , this function is called with relinfo as the * partitioned table , and src_partinfo and dst_partinfo referring to the * source and target leaf partitions , respectively . * * is_crosspart_update is true either when a DELETE event is fired on the * source partition ( which is to be ignored ) or an UPDATE event is fired on * the root partitioned table . * - - - - - - - - - - static void int event, bool row_trigger,bool is_crosspart_update)char relkind = rel->rd_rel->relkind;int tgtype_event;int tgtype_level;int i;/* * Check state . We use a normal test not Assert because it is possible to * reach here in the wrong state given misconfigured RI triggers , in * particular deferring a cascade action trigger . if (afterTriggers.query_depth < 0 )"AfterTriggerSaveEvent() called outside of query" );/* Be sure we have enough space to record events at this query depth. */ if (afterTriggers.query_depth >= afterTriggers.maxquerydepth)/* * If the directly named relation has any triggers with transition tables , * then we need to capture transition tuples . if (row_trigger && transition_capture != NULL)e;/* * Capture the old tuple in the appropriate transition table based on * the event . if (!TupIsNull(oldslot))/* * Capture the new tuple in the appropriate transition table based on * the event . if (!TupIsNull(newslot))/* * If transition tables are the only reason we ' re here , return . As * mentioned above , we can also be here during update tuple routing in * presence of transition tables , in which case this function is * called separately for OLD and NEW , so we expect exactly one of them * to be NULL . if (trigdesc == NULL ||return ;/* * We normally don ' t see partitioned tables here for row level triggers * except in the special case of a cross - partition update . In that case , * nodeModifyTable . c : ExecCrossPartitionUpdateForeignKey ( ) calls here to * queue an update event on the root target partitioned table , also * passing the source and destination partitions and their tuples . /* * Validate the event code and collect the associated tuple CTIDs . * * The event code will be used both as a bitmask and an array offset , so * validation is important to make sure we don ' t walk off the edge of our * arrays . * * Also , if we ' re considering statement - level triggers , check whether we * already queued a set of them for this event , and cancel the prior set * if so . This preserves the behavior that statement - level triggers fire * just once per statement and fire after row - level triggers . switch (event)case TRIGGER_EVENT_INSERT:if (row_trigger)else break ;case TRIGGER_EVENT_DELETE:if (row_trigger)else break ;case TRIGGER_EVENT_UPDATE:if (row_trigger)/* * Also remember the OIDs of partitions to fetch these tuples * out of later in AfterTriggerExecute ( ) . if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)else break ;case TRIGGER_EVENT_TRUNCATE:break ;default :"invalid after-trigger event code: %d" , event);0 ; /* keep compiler quiet */ break ;/* Determine flags */ if (!(relkind == RELKIND_FOREIGN_TABLE && row_trigger))if (row_trigger && event == TRIGGER_EVENT_UPDATE)if (relkind == RELKIND_PARTITIONED_TABLE)else else /* else, we'll initialize ate_flags for each trigger */ /* * Must convert / copy the source and destination partition tuples into the * root partitioned table ' s format / slot , because the processing in the * loop below expects both oldslot and newslot tuples to be in that form . if (row_trigger && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)if (map)else if (map)else for (i = 0 ; i < trigdesc->numtriggers; i++)if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,continue ;if (!TriggerEnabled(estate, relinfo, trigger, event,continue ;if (relkind == RELKIND_FOREIGN_TABLE && row_trigger)if (fdw_tuplestore == NULL)else /* subsequent event for the same tuple */ /* * If the trigger is a foreign key enforcement trigger , there are * certain cases where we can skip queueing the event because we can * tell by inspection that the FK constraint will still pass . There * are also some cases during cross - partition updates of a partitioned * table where queuing the event can be skipped . if (TRIGGER_FIRED_BY_UPDATE(event) || TRIGGER_FIRED_BY_DELETE(event))switch (RI_FKey_trigger_type(trigger->tgfoid))case RI_TRIGGER_PK:/* * For cross - partitioned updates of partitioned PK table , * skip the event fired by the component delete on the * source leaf partition unless the constraint originates * in the partition itself ( ! tgisclone ) , because the * update event that will be fired on the root * ( partitioned ) target table will be used to perform the * necessary foreign key enforcement action . if (is_crosspart_update &&continue ;/* Update or delete on trigger's PK table */ if (!RI_FKey_pk_upd_check_required(trigger, rel,/* skip queuing this event */ continue ;break ;case RI_TRIGGER_FK:/* * Update on trigger ' s FK table . We can skip the update * event fired on a partitioned table during a * cross - partition of that table , because the insert event * that is fired on the destination leaf partition would * suffice to perform the necessary foreign key check . * Moreover , RI_FKey_fk_upd_check_required ( ) expects to be * passed a tuple that contains system attributes , most of * which are not present in the virtual slot belonging to * a partitioned table . if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ||/* skip queuing this event */ continue ;break ;case RI_TRIGGER_NONE:/* * Not an FK trigger . No need to queue the update event * fired during a cross - partitioned update of a * partitioned table , because the same row trigger must be * present in the leaf partition ( s ) that are affected as * part of this update and the events fired on them are * queued instead . if (row_trigger &&continue ;break ;/* * If the trigger is a deferred unique constraint check trigger , only * queue it if the unique constraint was potentially violated , which * we know from index insertion time . if (trigger->tgfoid == F_UNIQUE_KEY_RECHECK)if (!list_member_oid(recheckIndexes, trigger->tgconstrindid))continue ; /* Uniqueness definitely not violated */ /* * Fill in event structure and add it to the current query ' s queue . * Note we set ats_table to NULL whenever this trigger doesn ' t use * transition tables , to improve sharability of the shared event data . 0 ) |0 ) |0 );0 ;if ((trigger->tgoldtable || trigger->tgnewtable) &&switch (event)case TRIGGER_EVENT_INSERT:break ;case TRIGGER_EVENT_UPDATE:break ;case TRIGGER_EVENT_DELETE:break ;default :/* Must be TRUNCATE, see switch above */ break ;else /* * Finally , spool any foreign tuple ( s ) . The tuplestore squashes them to * minimal tuples , so this loses any system columns . The executor lost * those columns before us , for an unrelated reason , so this is fine . if (fdw_tuplestore)if (oldslot != NULL)if (newslot != NULL)/* * Detect whether we already queued BEFORE STATEMENT triggers for the given * relation + operation , and set the flag so the next call will report " true " . static bool bool result;/* Check state, like AfterTriggerSaveEvent. */ if (afterTriggers.query_depth < 0 )"before_stmt_triggers_fired() called outside of query" );/* Be sure we have enough space to record events at this query depth. */ if (afterTriggers.query_depth >= afterTriggers.maxquerydepth)/* * We keep this state in the AfterTriggersTableData that also holds * transition tables for the relation + operation . In this way , if we are * forced to make a new set of transition tables because more tuples get * entered after we ' ve already fired triggers , we will allow a new set of * statement triggers to get queued . true ;return result;/* * If we previously queued a set of AFTER STATEMENT triggers for the given * relation + operation , and they ' ve not been fired yet , cancel them . The * caller will queue a fresh set that ' s after any row - level triggers that may * have been queued by the current sub - statement , preserving ( as much as * possible ) the property that AFTER ROW triggers fire before AFTER STATEMENT * triggers , and that the latter only fire once . This deals with the * situation where several FK enforcement triggers sequentially queue triggers * for the same table into the same trigger query level . We can ' t fully * prevent odd behavior though : if there are AFTER ROW triggers taking * transition tables , we don ' t want to change the transition tables once the * first such trigger has seen them . In such a case , any additional events * will result in creating new transition tables and allowing new firings of * statement triggers . * * This also saves the current event list location so that a later invocation * of this function can cheaply find the triggers we ' re about to queue and * cancel them . static void int tgevent)/* * We keep this state in the AfterTriggersTableData that also holds * transition tables for the relation + operation . In this way , if we are * forced to make a new set of transition tables because more tuples get * entered after we ' ve already fired triggers , we will allow a new set of * statement triggers to get queued without canceling the old ones . if (table->after_trig_done)/* * We want to start scanning from the tail location that existed just * before we inserted any statement triggers . But the events list * might ' ve been entirely empty then , in which case scan from the * current head . if (table->after_trig_events.tail)else if (event == NULL)/* * Exit loop when we reach events that aren ' t AS triggers for * the target relation . if (evtshared->ats_relid != relid)goto done;if ((evtshared->ats_event & TRIGGER_EVENT_OPMASK) != tgevent)goto done;if (!TRIGGER_FIRED_FOR_STATEMENT(evtshared->ats_event))goto done;if (!TRIGGER_FIRED_AFTER(evtshared->ats_event))goto done;/* OK, mark it DONE */ /* signal we must reinitialize event ptr for next chunk */ /* In any case, save current insertion point for next time */ true ;/* * GUC assign_hook for session_replication_role void int newval, void *extra)/* * Must flush the plan cache when changing replication role ; but don ' t * flush unnecessarily . if (SessionReplicationRole != newval)/* * SQL function pg_trigger_depth ( ) /* * Check whether a trigger modified a virtual generated column and replace the * value with null if so . * * We need to check this so that we don ' t end up storing a non - null value in a * virtual generated column . * * We don ' t need to check for stored generated columns , since those will be * overwritten later anyway . static HeapTupleif (!(tupdesc->constr && tupdesc->constr->has_generated_virtual))return tuple;for (int i = 0 ; i < tupdesc->natts; i++)if (TupleDescAttr(tupdesc, i)->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)if (!heap_attisnull(tuple, i + 1 , tupdesc))int replCol = i + 1 ;0 ;bool replIsnull = true ;1 , &replCol, &replValue, &replIsnull);return tuple;
Messung V0.5 in Prozent C=94 H=92 G=92
¤ Dauer der Verarbeitung: 0.438 Sekunden
(vorverarbeitet am 2026-08-08)
¤ *© Formatika GbR, Deutschland
