#include "access/tableam.h"
#include "catalog/objectaddress.h"
#include "nodes/execnodes.h"
#include "nodes/parsenodes.h"

Include dependency graph for trigger.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	TriggerData

struct	TransitionCaptureState

Macros
#define	CALLED_AS_TRIGGER(fcinfo) ((fcinfo)->context != NULL && IsA((fcinfo)->context, TriggerData))

#define	TRIGGER_EVENT_INSERT 0x00000000

#define	TRIGGER_EVENT_DELETE 0x00000001

#define	TRIGGER_EVENT_UPDATE 0x00000002

#define	TRIGGER_EVENT_TRUNCATE 0x00000003

#define	TRIGGER_EVENT_OPMASK 0x00000003

#define	TRIGGER_EVENT_ROW 0x00000004

#define	TRIGGER_EVENT_BEFORE 0x00000008

#define	TRIGGER_EVENT_AFTER 0x00000000

#define	TRIGGER_EVENT_INSTEAD 0x00000010

#define	TRIGGER_EVENT_TIMINGMASK 0x00000018

#define	AFTER_TRIGGER_DEFERRABLE 0x00000020

#define	AFTER_TRIGGER_INITDEFERRED 0x00000040

#define	TRIGGER_FIRED_BY_INSERT(event) (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_INSERT)

#define	TRIGGER_FIRED_BY_DELETE(event) (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_DELETE)

#define	TRIGGER_FIRED_BY_UPDATE(event) (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_UPDATE)

#define	TRIGGER_FIRED_BY_TRUNCATE(event) (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_TRUNCATE)

#define	TRIGGER_FIRED_FOR_ROW(event) ((event) & TRIGGER_EVENT_ROW)

#define	TRIGGER_FIRED_FOR_STATEMENT(event) (!TRIGGER_FIRED_FOR_ROW(event))

#define	TRIGGER_FIRED_BEFORE(event) (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_BEFORE)

#define	TRIGGER_FIRED_AFTER(event) (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_AFTER)

#define	TRIGGER_FIRED_INSTEAD(event) (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_INSTEAD)

#define	SESSION_REPLICATION_ROLE_ORIGIN 0

#define	SESSION_REPLICATION_ROLE_REPLICA 1

#define	SESSION_REPLICATION_ROLE_LOCAL 2

#define	TRIGGER_FIRES_ON_ORIGIN 'O'

#define	TRIGGER_FIRES_ALWAYS 'A'

#define	TRIGGER_FIRES_ON_REPLICA 'R'

#define	TRIGGER_DISABLED 'D'

#define	RI_TRIGGER_PK 1 /* is a trigger on the PK relation */

#define	RI_TRIGGER_FK 2 /* is a trigger on the FK relation */

#define	RI_TRIGGER_NONE 0 /* is not an RI trigger function */

Typedefs
typedef uint32	TriggerEvent

typedef struct TriggerData	TriggerData

typedef struct TransitionCaptureState	TransitionCaptureState

Functions
ObjectAddress	CreateTrigger (CreateTrigStmt stmt, const char queryString, Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid funcoid, Oid parentTriggerOid, Node *whenClause, bool isInternal, bool in_partition)

ObjectAddress	CreateTriggerFiringOn (CreateTrigStmt stmt, const char queryString, Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid funcoid, Oid parentTriggerOid, Node *whenClause, bool isInternal, bool in_partition, char trigger_fires_when)

void	TriggerSetParentTrigger (Relation trigRel, Oid childTrigId, Oid parentTrigId, Oid childTableId)

void	RemoveTriggerById (Oid trigOid)

Oid	get_trigger_oid (Oid relid, const char *trigname, bool missing_ok)

ObjectAddress	renametrig (RenameStmt *stmt)

void	EnableDisableTrigger (Relation rel, const char *tgname, Oid tgparent, char fires_when, bool skip_system, bool recurse, LOCKMODE lockmode)

void	RelationBuildTriggers (Relation relation)

TriggerDesc *	CopyTriggerDesc (TriggerDesc *trigdesc)

const char *	FindTriggerIncompatibleWithInheritance (TriggerDesc *trigdesc)

TransitionCaptureState *	MakeTransitionCaptureState (TriggerDesc *trigdesc, Oid relid, CmdType cmdType)

void	FreeTriggerDesc (TriggerDesc *trigdesc)

void	ExecBSInsertTriggers (EState estate, ResultRelInfo relinfo)

void	ExecASInsertTriggers (EState estate, ResultRelInfo relinfo, TransitionCaptureState *transition_capture)

bool	ExecBRInsertTriggers (EState estate, ResultRelInfo relinfo, TupleTableSlot *slot)

void	ExecARInsertTriggers (EState estate, ResultRelInfo relinfo, TupleTableSlot slot, List recheckIndexes, TransitionCaptureState *transition_capture)

bool	ExecIRInsertTriggers (EState estate, ResultRelInfo relinfo, TupleTableSlot *slot)

void	ExecBSDeleteTriggers (EState estate, ResultRelInfo relinfo)

void	ExecASDeleteTriggers (EState estate, ResultRelInfo relinfo, TransitionCaptureState *transition_capture)

bool	ExecBRDeleteTriggers (EState estate, EPQState epqstate, ResultRelInfo relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot epqslot, TM_Result tmresult, TM_FailureData *tmfd)

void	ExecARDeleteTriggers (EState estate, ResultRelInfo relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TransitionCaptureState *transition_capture, bool is_crosspart_update)

bool	ExecIRDeleteTriggers (EState estate, ResultRelInfo relinfo, HeapTuple trigtuple)

void	ExecBSUpdateTriggers (EState estate, ResultRelInfo relinfo)

void	ExecASUpdateTriggers (EState estate, ResultRelInfo relinfo, TransitionCaptureState *transition_capture)

bool	ExecBRUpdateTriggers (EState estate, EPQState epqstate, ResultRelInfo relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot newslot, TM_Result tmresult, TM_FailureData tmfd)

void	ExecARUpdateTriggers (EState estate, ResultRelInfo relinfo, ResultRelInfo src_partinfo, ResultRelInfo dst_partinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot newslot, List recheckIndexes, TransitionCaptureState *transition_capture, bool is_crosspart_update)

bool	ExecIRUpdateTriggers (EState estate, ResultRelInfo relinfo, HeapTuple trigtuple, TupleTableSlot *newslot)

void	ExecBSTruncateTriggers (EState estate, ResultRelInfo relinfo)

void	ExecASTruncateTriggers (EState estate, ResultRelInfo relinfo)

void	AfterTriggerBeginXact (void)

void	AfterTriggerBeginQuery (void)

void	AfterTriggerEndQuery (EState *estate)

void	AfterTriggerFireDeferred (void)

void	AfterTriggerEndXact (bool isCommit)

void	AfterTriggerBeginSubXact (void)

void	AfterTriggerEndSubXact (bool isCommit)

void	AfterTriggerSetState (ConstraintsSetStmt *stmt)

bool	AfterTriggerPendingOnRel (Oid relid)

bool	RI_FKey_pk_upd_check_required (Trigger trigger, Relation pk_rel, TupleTableSlot oldslot, TupleTableSlot *newslot)

bool	RI_FKey_fk_upd_check_required (Trigger trigger, Relation fk_rel, TupleTableSlot oldslot, TupleTableSlot *newslot)

bool	RI_Initial_Check (Trigger *trigger, Relation fk_rel, Relation pk_rel)

void	RI_PartitionRemove_Check (Trigger *trigger, Relation fk_rel, Relation pk_rel)

int	RI_FKey_trigger_type (Oid tgfoid)

Variables
PGDLLIMPORT int	SessionReplicationRole

Macro Definition Documentation

◆ AFTER_TRIGGER_DEFERRABLE

#define AFTER_TRIGGER_DEFERRABLE 0x00000020

Definition at line 107 of file trigger.h.

◆ AFTER_TRIGGER_INITDEFERRED

#define AFTER_TRIGGER_INITDEFERRED 0x00000040

Definition at line 108 of file trigger.h.

◆ CALLED_AS_TRIGGER

#define CALLED_AS_TRIGGER ( fcinfo ) ((fcinfo)->context != NULL && IsA((fcinfo)->context, TriggerData))

Definition at line 26 of file trigger.h.

◆ RI_TRIGGER_FK

#define RI_TRIGGER_FK 2 /* is a trigger on the FK relation */

Definition at line 283 of file trigger.h.

◆ RI_TRIGGER_NONE

#define RI_TRIGGER_NONE 0 /* is not an RI trigger function */

Definition at line 284 of file trigger.h.

◆ RI_TRIGGER_PK

#define RI_TRIGGER_PK 1 /* is a trigger on the PK relation */

Definition at line 282 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_LOCAL

#define SESSION_REPLICATION_ROLE_LOCAL 2

Definition at line 142 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_ORIGIN

#define SESSION_REPLICATION_ROLE_ORIGIN 0

Definition at line 140 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_REPLICA

#define SESSION_REPLICATION_ROLE_REPLICA 1

Definition at line 141 of file trigger.h.

◆ TRIGGER_DISABLED

#define TRIGGER_DISABLED 'D'

Definition at line 152 of file trigger.h.

◆ TRIGGER_EVENT_AFTER

#define TRIGGER_EVENT_AFTER 0x00000000

Definition at line 101 of file trigger.h.

◆ TRIGGER_EVENT_BEFORE

#define TRIGGER_EVENT_BEFORE 0x00000008

Definition at line 100 of file trigger.h.

◆ TRIGGER_EVENT_DELETE

#define TRIGGER_EVENT_DELETE 0x00000001

Definition at line 93 of file trigger.h.

◆ TRIGGER_EVENT_INSERT

#define TRIGGER_EVENT_INSERT 0x00000000

Definition at line 92 of file trigger.h.

◆ TRIGGER_EVENT_INSTEAD

#define TRIGGER_EVENT_INSTEAD 0x00000010

Definition at line 102 of file trigger.h.

◆ TRIGGER_EVENT_OPMASK

#define TRIGGER_EVENT_OPMASK 0x00000003

Definition at line 96 of file trigger.h.

◆ TRIGGER_EVENT_ROW

#define TRIGGER_EVENT_ROW 0x00000004

Definition at line 98 of file trigger.h.

◆ TRIGGER_EVENT_TIMINGMASK

#define TRIGGER_EVENT_TIMINGMASK 0x00000018

Definition at line 103 of file trigger.h.

◆ TRIGGER_EVENT_TRUNCATE

#define TRIGGER_EVENT_TRUNCATE 0x00000003

Definition at line 95 of file trigger.h.

◆ TRIGGER_EVENT_UPDATE

#define TRIGGER_EVENT_UPDATE 0x00000002

Definition at line 94 of file trigger.h.

◆ TRIGGER_FIRED_AFTER

#define TRIGGER_FIRED_AFTER ( event ) (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_AFTER)

Definition at line 131 of file trigger.h.

◆ TRIGGER_FIRED_BEFORE

#define TRIGGER_FIRED_BEFORE ( event ) (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_BEFORE)

Definition at line 128 of file trigger.h.

◆ TRIGGER_FIRED_BY_DELETE

#define TRIGGER_FIRED_BY_DELETE ( event ) (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_DELETE)

Definition at line 113 of file trigger.h.

◆ TRIGGER_FIRED_BY_INSERT

#define TRIGGER_FIRED_BY_INSERT ( event ) (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_INSERT)

Definition at line 110 of file trigger.h.

◆ TRIGGER_FIRED_BY_TRUNCATE

#define TRIGGER_FIRED_BY_TRUNCATE ( event ) (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_TRUNCATE)

Definition at line 119 of file trigger.h.

◆ TRIGGER_FIRED_BY_UPDATE

#define TRIGGER_FIRED_BY_UPDATE ( event ) (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_UPDATE)

Definition at line 116 of file trigger.h.

◆ TRIGGER_FIRED_FOR_ROW

#define TRIGGER_FIRED_FOR_ROW ( event ) ((event) & TRIGGER_EVENT_ROW)

Definition at line 122 of file trigger.h.

◆ TRIGGER_FIRED_FOR_STATEMENT

#define TRIGGER_FIRED_FOR_STATEMENT ( event ) (!TRIGGER_FIRED_FOR_ROW(event))

Definition at line 125 of file trigger.h.

◆ TRIGGER_FIRED_INSTEAD

#define TRIGGER_FIRED_INSTEAD ( event ) (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_INSTEAD)

Definition at line 134 of file trigger.h.

◆ TRIGGER_FIRES_ALWAYS

#define TRIGGER_FIRES_ALWAYS 'A'

Definition at line 150 of file trigger.h.

◆ TRIGGER_FIRES_ON_ORIGIN

#define TRIGGER_FIRES_ON_ORIGIN 'O'

Definition at line 149 of file trigger.h.

◆ TRIGGER_FIRES_ON_REPLICA

#define TRIGGER_FIRES_ON_REPLICA 'R'

Definition at line 151 of file trigger.h.

Typedef Documentation

◆ TransitionCaptureState

typedef struct TransitionCaptureState TransitionCaptureState

◆ TriggerData

typedef struct TriggerData TriggerData

◆ TriggerEvent

typedef uint32 TriggerEvent

Definition at line 29 of file trigger.h.

Function Documentation

◆ AfterTriggerBeginQuery()

void AfterTriggerBeginQuery ( void )

Definition at line 4980 of file trigger.c.

 {
     /* Increase the query stack depth */
     afterTriggers.query_depth++;
 }

References afterTriggers, and AfterTriggersData::query_depth.

Referenced by CopyFrom(), create_edata_for_relation(), ExecuteTruncateGuts(), and standard_ExecutorStart().

◆ AfterTriggerBeginSubXact()

void AfterTriggerBeginSubXact ( void )

Definition at line 5263 of file trigger.c.

 {
     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 */
             afterTriggers.trans_stack = (AfterTriggersTransData *)
                 MemoryContextAlloc(TopTransactionContext,
                                    8 * sizeof(AfterTriggersTransData));
             afterTriggers.maxtransdepth = 8;
         }
         else
         {
             /* repalloc will keep the stack in the same context */
             int         new_alloc = afterTriggers.maxtransdepth * 2;
  
             afterTriggers.trans_stack = (AfterTriggersTransData *)
                 repalloc(afterTriggers.trans_stack,
                          new_alloc * sizeof(AfterTriggersTransData));
             afterTriggers.maxtransdepth = new_alloc;
         }
     }
  
     /*
      * 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.
      */
     afterTriggers.trans_stack[my_level].state = NULL;
     afterTriggers.trans_stack[my_level].events = afterTriggers.events;
     afterTriggers.trans_stack[my_level].query_depth = afterTriggers.query_depth;
     afterTriggers.trans_stack[my_level].firing_counter = afterTriggers.firing_counter;
 }

References afterTriggers, AfterTriggersData::events, AfterTriggersTransData::events, AfterTriggersData::firing_counter, AfterTriggersTransData::firing_counter, GetCurrentTransactionNestLevel(), AfterTriggersData::maxtransdepth, MemoryContextAlloc(), AfterTriggersData::query_depth, AfterTriggersTransData::query_depth, repalloc(), AfterTriggersTransData::state, TopTransactionContext, and AfterTriggersData::trans_stack.

Referenced by StartSubTransaction().

◆ AfterTriggerBeginXact()

void AfterTriggerBeginXact ( void )

Definition at line 4948 of file trigger.c.

 {
     /*
      * Initialize after-trigger state structure to empty
      */
     afterTriggers.firing_counter = (CommandId) 1;   /* mustn't be 0 */
     afterTriggers.query_depth = -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.
      */
     Assert(afterTriggers.state == NULL);
     Assert(afterTriggers.query_stack == NULL);
     Assert(afterTriggers.maxquerydepth == 0);
     Assert(afterTriggers.event_cxt == NULL);
     Assert(afterTriggers.events.head == NULL);
     Assert(afterTriggers.trans_stack == NULL);
     Assert(afterTriggers.maxtransdepth == 0);
 }

References afterTriggers, Assert(), AfterTriggersData::event_cxt, AfterTriggersData::events, AfterTriggersData::firing_counter, AfterTriggerEventList::head, AfterTriggersData::maxquerydepth, AfterTriggersData::maxtransdepth, AfterTriggersData::query_depth, AfterTriggersData::query_stack, AfterTriggersData::state, and AfterTriggersData::trans_stack.

Referenced by StartTransaction().

◆ AfterTriggerEndQuery()

void AfterTriggerEndQuery ( EState * estate )

Definition at line 5000 of file trigger.c.

 {
     AfterTriggersQueryData *qs;
  
     /* Must be inside a query, too */
     Assert(afterTriggers.query_depth >= 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)
     {
         afterTriggers.query_depth--;
         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.
      */
     qs = &afterTriggers.query_stack[afterTriggers.query_depth];
  
     for (;;)
     {
         if (afterTriggerMarkEvents(&qs->events, &afterTriggers.events, true))
         {
             CommandId   firing_id = afterTriggers.firing_counter++;
             AfterTriggerEventChunk *oldtail = qs->events.tail;
  
             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.
              */
             qs = &afterTriggers.query_stack[afterTriggers.query_depth];
  
             /*
              * 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.
              */
             Assert(oldtail != NULL);
             while (qs->events.head != oldtail)
                 afterTriggerDeleteHeadEventChunk(qs);
         }
         else
             break;
     }
  
     /* Release query-level-local storage, including tuplestores if any */
     AfterTriggerFreeQuery(&afterTriggers.query_stack[afterTriggers.query_depth]);
  
     afterTriggers.query_depth--;
 }

References afterTriggerDeleteHeadEventChunk(), AfterTriggerFreeQuery(), afterTriggerInvokeEvents(), afterTriggerMarkEvents(), afterTriggers, Assert(), AfterTriggersData::events, AfterTriggersQueryData::events, AfterTriggersData::firing_counter, AfterTriggerEventList::head, AfterTriggersData::maxquerydepth, AfterTriggersData::query_depth, AfterTriggersData::query_stack, and AfterTriggerEventList::tail.

Referenced by CopyFrom(), ExecuteTruncateGuts(), finish_edata(), and standard_ExecutorFinish().

◆ AfterTriggerEndSubXact()

void AfterTriggerEndSubXact ( bool isCommit )

Definition at line 5311 of file trigger.c.

 {
     int         my_level = GetCurrentTransactionNestLevel();
     SetConstraintState state;
     AfterTriggerEvent event;
     AfterTriggerEventChunk *chunk;
     CommandId   subxact_firing_id;
  
     /*
      * Pop the prior state if needed.
      */
     if (isCommit)
     {
         Assert(my_level < afterTriggers.maxtransdepth);
         /* If we saved a prior state, we don't need it anymore */
         state = afterTriggers.trans_stack[my_level].state;
         if (state != NULL)
             pfree(state);
         /* this avoids double pfree if error later: */
         afterTriggers.trans_stack[my_level].state = NULL;
         Assert(afterTriggers.query_depth ==
                afterTriggers.trans_stack[my_level].query_depth);
     }
     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)
                 AfterTriggerFreeQuery(&afterTriggers.query_stack[afterTriggers.query_depth]);
             afterTriggers.query_depth--;
         }
         Assert(afterTriggers.query_depth ==
                afterTriggers.trans_stack[my_level].query_depth);
  
         /*
          * Restore the global deferred-event list to its former length,
          * discarding any events queued by the subxact.
          */
         afterTriggerRestoreEventList(&afterTriggers.events,
                                      &afterTriggers.trans_stack[my_level].events);
  
         /*
          * Restore the trigger state.  If the saved state is NULL, then this
          * subxact didn't save it, so it doesn't need restoring.
          */
         state = afterTriggers.trans_stack[my_level].state;
         if (state != NULL)
         {
             pfree(afterTriggers.state);
             afterTriggers.state = state;
         }
         /* this avoids double pfree if error later: */
         afterTriggers.trans_stack[my_level].state = NULL;
  
         /*
          * 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.)
          */
         subxact_firing_id = afterTriggers.trans_stack[my_level].firing_counter;
         for_each_event_chunk(event, chunk, afterTriggers.events)
         {
             AfterTriggerShared evtshared = GetTriggerSharedData(event);
  
             if (event->ate_flags &
                 (AFTER_TRIGGER_DONE | AFTER_TRIGGER_IN_PROGRESS))
             {
                 if (evtshared->ats_firing_id >= subxact_firing_id)
                     event->ate_flags &=
                         ~(AFTER_TRIGGER_DONE | AFTER_TRIGGER_IN_PROGRESS);
             }
         }
     }
 }

References AFTER_TRIGGER_DONE, AFTER_TRIGGER_IN_PROGRESS, AfterTriggerFreeQuery(), afterTriggerRestoreEventList(), afterTriggers, Assert(), AfterTriggerEventData::ate_flags, AfterTriggerSharedData::ats_firing_id, AfterTriggersData::events, AfterTriggersTransData::events, AfterTriggersTransData::firing_counter, for_each_event_chunk, GetCurrentTransactionNestLevel(), GetTriggerSharedData, AfterTriggersData::maxquerydepth, AfterTriggersData::maxtransdepth, pfree(), AfterTriggersData::query_depth, AfterTriggersTransData::query_depth, AfterTriggersData::query_stack, AfterTriggersData::state, AfterTriggersTransData::state, and AfterTriggersData::trans_stack.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AfterTriggerEndXact()

void AfterTriggerEndXact ( bool isCommit )

Definition at line 5215 of file trigger.c.

 {
     /*
      * 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)
     {
         MemoryContextDelete(afterTriggers.event_cxt);
         afterTriggers.event_cxt = NULL;
         afterTriggers.events.head = NULL;
         afterTriggers.events.tail = NULL;
         afterTriggers.events.tailfree = NULL;
     }
  
     /*
      * 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.
      */
     afterTriggers.trans_stack = NULL;
     afterTriggers.maxtransdepth = 0;
  
  
     /*
      * Forget the query stack and constraint-related state information.  As
      * with the subtransaction state information, we don't bother freeing the
      * memory here.
      */
     afterTriggers.query_stack = NULL;
     afterTriggers.maxquerydepth = 0;
     afterTriggers.state = NULL;
  
     /* No more afterTriggers manipulation until next transaction starts. */
     afterTriggers.query_depth = -1;
 }

References afterTriggers, AfterTriggersData::event_cxt, AfterTriggersData::events, AfterTriggerEventList::head, AfterTriggersData::maxquerydepth, AfterTriggersData::maxtransdepth, MemoryContextDelete(), AfterTriggersData::query_depth, AfterTriggersData::query_stack, AfterTriggersData::state, AfterTriggerEventList::tail, AfterTriggerEventList::tailfree, and AfterTriggersData::trans_stack.

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

◆ AfterTriggerFireDeferred()

void AfterTriggerFireDeferred ( void )

Definition at line 5159 of file trigger.c.

 {
     AfterTriggerEventList *events;
     bool        snap_pushed = false;
  
     /* Must not be inside a query */
     Assert(afterTriggers.query_depth == -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.)
      */
     events = &afterTriggers.events;
     if (events->head != NULL)
     {
         PushActiveSnapshot(GetTransactionSnapshot());
         snap_pushed = 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))
     {
         CommandId   firing_id = afterTriggers.firing_counter++;
  
         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)
         PopActiveSnapshot();
 }

References afterTriggerInvokeEvents(), afterTriggerMarkEvents(), afterTriggers, Assert(), AfterTriggersData::events, AfterTriggersData::firing_counter, GetTransactionSnapshot(), AfterTriggerEventList::head, PopActiveSnapshot(), PushActiveSnapshot(), and AfterTriggersData::query_depth.

Referenced by CommitTransaction(), and PrepareTransaction().

◆ AfterTriggerPendingOnRel()

bool AfterTriggerPendingOnRel ( Oid relid )

Definition at line 5936 of file trigger.c.

 {
     AfterTriggerEvent event;
     AfterTriggerEventChunk *chunk;
     int         depth;
  
     /* Scan queued events */
     for_each_event_chunk(event, chunk, afterTriggers.events)
     {
         AfterTriggerShared evtshared = GetTriggerSharedData(event);
  
         /*
          * 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++)
     {
         for_each_event_chunk(event, chunk, afterTriggers.query_stack[depth].events)
         {
             AfterTriggerShared evtshared = GetTriggerSharedData(event);
  
             if (event->ate_flags & AFTER_TRIGGER_DONE)
                 continue;
  
             if (evtshared->ats_relid == relid)
                 return true;
         }
     }
  
     return false;
 }

References AFTER_TRIGGER_DONE, afterTriggers, AfterTriggerEventData::ate_flags, AfterTriggerSharedData::ats_relid, AfterTriggersData::events, AfterTriggersQueryData::events, for_each_event_chunk, GetTriggerSharedData, AfterTriggersData::maxquerydepth, AfterTriggersData::query_depth, and AfterTriggersData::query_stack.

Referenced by CheckTableNotInUse().

◆ AfterTriggerSetState()

void AfterTriggerSetState ( ConstraintsSetStmt * stmt )

Definition at line 5621 of file trigger.c.

 {
     int         my_level = GetCurrentTransactionNestLevel();
  
     /* If we haven't already done so, initialize our state. */
     if (afterTriggers.state == NULL)
         afterTriggers.state = SetConstraintStateCreate(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 &&
         afterTriggers.trans_stack[my_level].state == NULL)
     {
         afterTriggers.trans_stack[my_level].state =
             SetConstraintStateCopy(afterTriggers.state);
     }
  
     /*
      * Handle SET CONSTRAINTS ALL ...
      */
     if (stmt->constraints == NIL)
     {
         /*
          * Forget any previous SET CONSTRAINTS commands in this transaction.
          */
         afterTriggers.state->numstates = 0;
  
         /*
          * Set the per-transaction ALL state to known.
          */
         afterTriggers.state->all_isset = true;
         afterTriggers.state->all_isdeferred = stmt->deferred;
     }
     else
     {
         Relation    conrel;
         Relation    tgrel;
         List       *conoidlist = NIL;
         List       *tgoidlist = NIL;
         ListCell   *lc;
  
         /*
          * 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.
          */
         conrel = table_open(ConstraintRelationId, AccessShareLock);
  
         foreach(lc, stmt->constraints)
         {
             RangeVar   *constraint = lfirst(lc);
             bool        found;
             List       *namespacelist;
             ListCell   *nslc;
  
             if (constraint->catalogname)
             {
                 if (strcmp(constraint->catalogname, get_database_name(MyDatabaseId)) != 0)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
                                     constraint->catalogname, constraint->schemaname,
                                     constraint->relname)));
             }
  
             /*
              * 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)
             {
                 Oid         namespaceId = LookupExplicitNamespace(constraint->schemaname,
                                                                   false);
  
                 namespacelist = list_make1_oid(namespaceId);
             }
             else
             {
                 namespacelist = fetch_search_path(true);
             }
  
             found = false;
             foreach(nslc, namespacelist)
             {
                 Oid         namespaceId = lfirst_oid(nslc);
                 SysScanDesc conscan;
                 ScanKeyData skey[2];
                 HeapTuple   tup;
  
                 ScanKeyInit(&skey[0],
                             Anum_pg_constraint_conname,
                             BTEqualStrategyNumber, F_NAMEEQ,
                             CStringGetDatum(constraint->relname));
                 ScanKeyInit(&skey[1],
                             Anum_pg_constraint_connamespace,
                             BTEqualStrategyNumber, F_OIDEQ,
                             ObjectIdGetDatum(namespaceId));
  
                 conscan = systable_beginscan(conrel, ConstraintNameNspIndexId,
                                              true, NULL, 2, skey);
  
                 while (HeapTupleIsValid(tup = systable_getnext(conscan)))
                 {
                     Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tup);
  
                     if (con->condeferrable)
                         conoidlist = lappend_oid(conoidlist, con->oid);
                     else if (stmt->deferred)
                         ereport(ERROR,
                                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                                  errmsg("constraint \"%s\" is not deferrable",
                                         constraint->relname)));
                     found = true;
                 }
  
                 systable_endscan(conscan);
  
                 /*
                  * Once we've found a matching constraint we do not search
                  * later parts of the search path.
                  */
                 if (found)
                     break;
             }
  
             list_free(namespacelist);
  
             /*
              * Not found ?
              */
             if (!found)
                 ereport(ERROR,
                         (errcode(ERRCODE_UNDEFINED_OBJECT),
                          errmsg("constraint \"%s\" does not exist",
                                 constraint->relname)));
         }
  
         /*
          * 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.
          */
         foreach(lc, conoidlist)
         {
             Oid         parent = lfirst_oid(lc);
             ScanKeyData key;
             SysScanDesc scan;
             HeapTuple   tuple;
  
             ScanKeyInit(&key,
                         Anum_pg_constraint_conparentid,
                         BTEqualStrategyNumber, F_OIDEQ,
                         ObjectIdGetDatum(parent));
  
             scan = systable_beginscan(conrel, ConstraintParentIndexId, true, NULL, 1, &key);
  
             while (HeapTupleIsValid(tuple = systable_getnext(scan)))
             {
                 Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tuple);
  
                 conoidlist = lappend_oid(conoidlist, con->oid);
             }
  
             systable_endscan(scan);
         }
  
         table_close(conrel, AccessShareLock);
  
         /*
          * Now, locate the trigger(s) implementing each of these constraints,
          * and make a list of their OIDs.
          */
         tgrel = table_open(TriggerRelationId, AccessShareLock);
  
         foreach(lc, conoidlist)
         {
             Oid         conoid = lfirst_oid(lc);
             ScanKeyData skey;
             SysScanDesc tgscan;
             HeapTuple   htup;
  
             ScanKeyInit(&skey,
                         Anum_pg_trigger_tgconstraint,
                         BTEqualStrategyNumber, F_OIDEQ,
                         ObjectIdGetDatum(conoid));
  
             tgscan = systable_beginscan(tgrel, TriggerConstraintIndexId, true,
                                         NULL, 1, &skey);
  
             while (HeapTupleIsValid(htup = systable_getnext(tgscan)))
             {
                 Form_pg_trigger pg_trigger = (Form_pg_trigger) GETSTRUCT(htup);
  
                 /*
                  * 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)
                     tgoidlist = lappend_oid(tgoidlist, pg_trigger->oid);
             }
  
             systable_endscan(tgscan);
         }
  
         table_close(tgrel, AccessShareLock);
  
         /*
          * Now we can set the trigger states of individual triggers for this
          * xact.
          */
         foreach(lc, tgoidlist)
         {
             Oid         tgoid = lfirst_oid(lc);
             SetConstraintState state = afterTriggers.state;
             bool        found = false;
             int         i;
  
             for (i = 0; i < state->numstates; i++)
             {
                 if (state->trigstates[i].sct_tgoid == tgoid)
                 {
                     state->trigstates[i].sct_tgisdeferred = stmt->deferred;
                     found = true;
                     break;
                 }
             }
             if (!found)
             {
                 afterTriggers.state =
                     SetConstraintStateAddItem(state, tgoid, stmt->deferred);
             }
         }
     }
  
     /*
      * 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)
     {
         AfterTriggerEventList *events = &afterTriggers.events;
         bool        snapshot_set = false;
  
         while (afterTriggerMarkEvents(events, NULL, true))
         {
             CommandId   firing_id = afterTriggers.firing_counter++;
  
             /*
              * 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)
             {
                 PushActiveSnapshot(GetTransactionSnapshot());
                 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,
                                          !IsSubTransaction()))
                 break;          /* all fired */
         }
  
         if (snapshot_set)
             PopActiveSnapshot();
     }
 }

References AccessShareLock, afterTriggerInvokeEvents(), afterTriggerMarkEvents(), afterTriggers, SetConstraintStateData::all_isdeferred, SetConstraintStateData::all_isset, BTEqualStrategyNumber, RangeVar::catalogname, CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, AfterTriggersData::events, fetch_search_path(), AfterTriggersData::firing_counter, get_database_name(), GetCurrentTransactionNestLevel(), GETSTRUCT, GetTransactionSnapshot(), HeapTupleIsValid, i, IsSubTransaction(), sort-test::key, lappend_oid(), lfirst, lfirst_oid, list_free(), list_make1_oid, LookupExplicitNamespace(), MyDatabaseId, NIL, SetConstraintStateData::numstates, ObjectIdGetDatum(), PopActiveSnapshot(), PushActiveSnapshot(), RangeVar::relname, ScanKeyInit(), RangeVar::schemaname, SetConstraintStateAddItem(), SetConstraintStateCopy(), SetConstraintStateCreate(), AfterTriggersData::state, AfterTriggersTransData::state, stmt, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and AfterTriggersData::trans_stack.

Referenced by standard_ProcessUtility().

◆ CopyTriggerDesc()

TriggerDesc* CopyTriggerDesc ( TriggerDesc * trigdesc )

Definition at line 2096 of file trigger.c.

 {
     TriggerDesc *newdesc;
     Trigger    *trigger;
     int         i;
  
     if (trigdesc == NULL || trigdesc->numtriggers <= 0)
         return NULL;
  
     newdesc = (TriggerDesc *) palloc(sizeof(TriggerDesc));
     memcpy(newdesc, trigdesc, sizeof(TriggerDesc));
  
     trigger = (Trigger *) palloc(trigdesc->numtriggers * sizeof(Trigger));
     memcpy(trigger, trigdesc->triggers,
            trigdesc->numtriggers * sizeof(Trigger));
     newdesc->triggers = trigger;
  
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         trigger->tgname = pstrdup(trigger->tgname);
         if (trigger->tgnattr > 0)
         {
             int16      *newattr;
  
             newattr = (int16 *) palloc(trigger->tgnattr * sizeof(int16));
             memcpy(newattr, trigger->tgattr,
                    trigger->tgnattr * sizeof(int16));
             trigger->tgattr = newattr;
         }
         if (trigger->tgnargs > 0)
         {
             char      **newargs;
             int16       j;
  
             newargs = (char **) palloc(trigger->tgnargs * sizeof(char *));
             for (j = 0; j < trigger->tgnargs; j++)
                 newargs[j] = pstrdup(trigger->tgargs[j]);
             trigger->tgargs = newargs;
         }
         if (trigger->tgqual)
             trigger->tgqual = pstrdup(trigger->tgqual);
         if (trigger->tgoldtable)
             trigger->tgoldtable = pstrdup(trigger->tgoldtable);
         if (trigger->tgnewtable)
             trigger->tgnewtable = pstrdup(trigger->tgnewtable);
         trigger++;
     }
  
     return newdesc;
 }

References i, j, TriggerDesc::numtriggers, palloc(), pstrdup(), Trigger::tgargs, Trigger::tgattr, Trigger::tgname, Trigger::tgnargs, Trigger::tgnattr, Trigger::tgnewtable, Trigger::tgoldtable, Trigger::tgqual, and TriggerDesc::triggers.

Referenced by InitResultRelInfo(), and RelationBuildTriggers().

◆ CreateTrigger()

ObjectAddress CreateTrigger	(	CreateTrigStmt *	stmt,
		const char *	queryString,
		Oid	relOid,
		Oid	refRelOid,
		Oid	constraintOid,
		Oid	indexOid,
		Oid	funcoid,
		Oid	parentTriggerOid,
		Node *	whenClause,
		bool	isInternal,
		bool	in_partition
	)

Definition at line 165 of file trigger.c.

 {
     return
         CreateTriggerFiringOn(stmt, queryString, relOid, refRelOid,
                               constraintOid, indexOid, funcoid,
                               parentTriggerOid, whenClause, isInternal,
                               in_partition, TRIGGER_FIRES_ON_ORIGIN);
 }

References CreateTriggerFiringOn(), stmt, and TRIGGER_FIRES_ON_ORIGIN.

Referenced by CreateFKCheckTrigger(), createForeignKeyActionTriggers(), index_constraint_create(), and ProcessUtilitySlow().

◆ CreateTriggerFiringOn()

ObjectAddress CreateTriggerFiringOn	(	CreateTrigStmt *	stmt,
		const char *	queryString,
		Oid	relOid,
		Oid	refRelOid,
		Oid	constraintOid,
		Oid	indexOid,
		Oid	funcoid,
		Oid	parentTriggerOid,
		Node *	whenClause,
		bool	isInternal,
		bool	in_partition,
		char	trigger_fires_when
	)

Definition at line 182 of file trigger.c.

 {
     int16       tgtype;
     int         ncolumns;
     int16      *columns;
     int2vector *tgattr;
     List       *whenRtable;
     char       *qual;
     Datum       values[Natts_pg_trigger];
     bool        nulls[Natts_pg_trigger];
     Relation    rel;
     AclResult   aclresult;
     Relation    tgrel;
     Relation    pgrel;
     HeapTuple   tuple = NULL;
     Oid         funcrettype;
     Oid         trigoid = InvalidOid;
     char        internaltrigname[NAMEDATALEN];
     char       *trigname;
     Oid         constrrelid = InvalidOid;
     ObjectAddress myself,
                 referenced;
     char       *oldtablename = NULL;
     char       *newtablename = NULL;
     bool        partition_recurse;
     bool        trigger_exists = false;
     Oid         existing_constraint_oid = InvalidOid;
     bool        existing_isInternal = false;
     bool        existing_isClone = false;
  
     if (OidIsValid(relOid))
         rel = table_open(relOid, ShareRowExclusiveLock);
     else
         rel = table_openrv(stmt->relation, ShareRowExclusiveLock);
  
     /*
      * 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 &&
             stmt->timing != TRIGGER_TYPE_AFTER)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("\"%s\" is a table",
                             RelationGetRelationName(rel)),
                      errdetail("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 &&
             stmt->timing != TRIGGER_TYPE_AFTER)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("\"%s\" is a table",
                             RelationGetRelationName(rel)),
                      errdetail("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)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("\"%s\" is a partitioned table",
                                 RelationGetRelationName(rel)),
                          errdetail("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)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("\"%s\" is a view",
                             RelationGetRelationName(rel)),
                      errdetail("Views cannot have row-level BEFORE or AFTER triggers.")));
         /* Disallow TRUNCATE triggers on VIEWs */
         if (TRIGGER_FOR_TRUNCATE(stmt->events))
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("\"%s\" is a view",
                             RelationGetRelationName(rel)),
                      errdetail("Views cannot have TRUNCATE triggers.")));
     }
     else if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
     {
         if (stmt->timing != TRIGGER_TYPE_BEFORE &&
             stmt->timing != TRIGGER_TYPE_AFTER)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("\"%s\" is a foreign table",
                             RelationGetRelationName(rel)),
                      errdetail("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)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("\"%s\" is a foreign table",
                             RelationGetRelationName(rel)),
                      errdetail("Foreign tables cannot have constraint triggers.")));
     }
     else
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("relation \"%s\" cannot have triggers",
                         RelationGetRelationName(rel)),
                  errdetail_relkind_not_supported(rel->rd_rel->relkind)));
  
     if (!allowSystemTableMods && IsSystemRelation(rel))
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("permission denied: \"%s\" is a system catalog",
                         RelationGetRelationName(rel))));
  
     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))
         {
             LockRelationOid(refRelOid, AccessShareLock);
             constrrelid = refRelOid;
         }
         else if (stmt->constrrel != NULL)
             constrrelid = RangeVarGetRelid(stmt->constrrel, AccessShareLock,
                                            false);
     }
  
     /* permission checks */
     if (!isInternal)
     {
         aclresult = pg_class_aclcheck(RelationGetRelid(rel), GetUserId(),
                                       ACL_TRIGGER);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, get_relkind_objtype(rel->rd_rel->relkind),
                            RelationGetRelationName(rel));
  
         if (OidIsValid(constrrelid))
         {
             aclresult = pg_class_aclcheck(constrrelid, GetUserId(),
                                           ACL_TRIGGER);
             if (aclresult != ACLCHECK_OK)
                 aclcheck_error(aclresult, get_relkind_objtype(get_rel_relkind(constrrelid)),
                                get_rel_name(constrrelid));
         }
     }
  
     /*
      * 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.
      */
     partition_recurse = !isInternal && stmt->row &&
         rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE;
     if (partition_recurse)
         list_free(find_all_inheritors(RelationGetRelid(rel),
                                       ShareRowExclusiveLock, NULL));
  
     /* Compute tgtype */
     TRIGGER_CLEAR_TYPE(tgtype);
     if (stmt->row)
         TRIGGER_SETT_ROW(tgtype);
     tgtype |= stmt->timing;
     tgtype |= stmt->events;
  
     /* Disallow ROW-level TRUNCATE triggers */
     if (TRIGGER_FOR_ROW(tgtype) && TRIGGER_FOR_TRUNCATE(tgtype))
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("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))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("INSTEAD OF triggers must be FOR EACH ROW")));
         if (stmt->whenClause)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("INSTEAD OF triggers cannot have WHEN conditions")));
         if (stmt->columns != NIL)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("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)
     {
         List       *varList = stmt->transitionRels;
         ListCell   *lc;
  
         foreach(lc, varList)
         {
             TriggerTransition *tt = lfirst_node(TriggerTransition, lc);
  
             if (!(tt->isTable))
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("ROW variable naming in the REFERENCING clause is not supported"),
                          errhint("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)
                 ereport(ERROR,
                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                          errmsg("\"%s\" is a foreign table",
                                 RelationGetRelationName(rel)),
                          errdetail("Triggers on foreign tables cannot have transition tables.")));
  
             if (rel->rd_rel->relkind == RELKIND_VIEW)
                 ereport(ERROR,
                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                          errmsg("\"%s\" is a view",
                                 RelationGetRelationName(rel)),
                          errdetail("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)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("ROW triggers with transition tables are not supported on partitions")));
                 else
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("ROW triggers with transition tables are not supported on inheritance children")));
             }
  
             if (stmt->timing != TRIGGER_TYPE_AFTER)
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                          errmsg("transition table name can only be specified for an AFTER trigger")));
  
             if (TRIGGER_FOR_TRUNCATE(tgtype))
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("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) +
                  (TRIGGER_FOR_UPDATE(tgtype) ? 1 : 0) +
                  (TRIGGER_FOR_DELETE(tgtype) ? 1 : 0)) != 1)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("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)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("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.
              */
             Assert(!stmt->isconstraint);
  
             if (tt->isNew)
             {
                 if (!(TRIGGER_FOR_INSERT(tgtype) ||
                       TRIGGER_FOR_UPDATE(tgtype)))
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                              errmsg("NEW TABLE can only be specified for an INSERT or UPDATE trigger")));
  
                 if (newtablename != NULL)
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                              errmsg("NEW TABLE cannot be specified multiple times")));
  
                 newtablename = tt->name;
             }
             else
             {
                 if (!(TRIGGER_FOR_DELETE(tgtype) ||
                       TRIGGER_FOR_UPDATE(tgtype)))
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                              errmsg("OLD TABLE can only be specified for a DELETE or UPDATE trigger")));
  
                 if (oldtablename != NULL)
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                              errmsg("OLD TABLE cannot be specified multiple times")));
  
                 oldtablename = tt->name;
             }
         }
  
         if (newtablename != NULL && oldtablename != NULL &&
             strcmp(newtablename, oldtablename) == 0)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("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)
     {
         ParseState *pstate;
         ParseNamespaceItem *nsitem;
         List       *varList;
         ListCell   *lc;
  
         /* Set up a pstate to parse with */
         pstate = make_parsestate(NULL);
         pstate->p_sourcetext = queryString;
  
         /*
          * Set up nsitems for OLD and NEW references.
          *
          * 'OLD' must always have varno equal to 1 and 'NEW' equal to 2.
          */
         nsitem = addRangeTableEntryForRelation(pstate, rel,
                                                AccessShareLock,
                                                makeAlias("old", NIL),
                                                false, false);
         addNSItemToQuery(pstate, nsitem, false, true, true);
         nsitem = addRangeTableEntryForRelation(pstate, rel,
                                                AccessShareLock,
                                                makeAlias("new", NIL),
                                                false, false);
         addNSItemToQuery(pstate, nsitem, false, true, true);
  
         /* Transform expression.  Copy to be sure we don't modify original */
         whenClause = transformWhereClause(pstate,
                                           copyObject(stmt->whenClause),
                                           EXPR_KIND_TRIGGER_WHEN,
                                           "WHEN");
         /* we have to fix its collations too */
         assign_expr_collations(pstate, whenClause);
  
         /*
          * 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.
          */
         varList = pull_var_clause(whenClause, 0);
         foreach(lc, varList)
         {
             Var        *var = (Var *) lfirst(lc);
  
             switch (var->varno)
             {
                 case PRS2_OLD_VARNO:
                     if (!TRIGGER_FOR_ROW(tgtype))
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("statement trigger's WHEN condition cannot reference column values"),
                                  parser_errposition(pstate, var->location)));
                     if (TRIGGER_FOR_INSERT(tgtype))
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("INSERT trigger's WHEN condition cannot reference OLD values"),
                                  parser_errposition(pstate, var->location)));
                     /* system columns are okay here */
                     break;
                 case PRS2_NEW_VARNO:
                     if (!TRIGGER_FOR_ROW(tgtype))
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("statement trigger's WHEN condition cannot reference column values"),
                                  parser_errposition(pstate, var->location)));
                     if (TRIGGER_FOR_DELETE(tgtype))
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("DELETE trigger's WHEN condition cannot reference NEW values"),
                                  parser_errposition(pstate, var->location)));
                     if (var->varattno < 0 && TRIGGER_FOR_BEFORE(tgtype))
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("BEFORE trigger's WHEN condition cannot reference NEW system columns"),
                                  parser_errposition(pstate, var->location)));
                     if (TRIGGER_FOR_BEFORE(tgtype) &&
                         var->varattno == 0 &&
                         RelationGetDescr(rel)->constr &&
                         RelationGetDescr(rel)->constr->has_generated_stored)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("BEFORE trigger's WHEN condition cannot reference NEW generated columns"),
                                  errdetail("A whole-row reference is used and the table contains generated columns."),
                                  parser_errposition(pstate, var->location)));
                     if (TRIGGER_FOR_BEFORE(tgtype) &&
                         var->varattno > 0 &&
                         TupleDescAttr(RelationGetDescr(rel), var->varattno - 1)->attgenerated)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("BEFORE trigger's WHEN condition cannot reference NEW generated columns"),
                                  errdetail("Column \"%s\" is a generated column.",
                                            NameStr(TupleDescAttr(RelationGetDescr(rel), var->varattno - 1)->attname)),
                                  parser_errposition(pstate, var->location)));
                     break;
                 default:
                     /* can't happen without add_missing_from, so just elog */
                     elog(ERROR, "trigger WHEN condition cannot contain references to other relations");
                     break;
             }
         }
  
         /* we'll need the rtable for recordDependencyOnExpr */
         whenRtable = pstate->p_rtable;
  
         qual = nodeToString(whenClause);
  
         free_parsestate(pstate);
     }
     else if (!whenClause)
     {
         whenClause = NULL;
         whenRtable = NIL;
         qual = NULL;
     }
     else
     {
         qual = nodeToString(whenClause);
         whenRtable = NIL;
     }
  
     /*
      * Find and validate the trigger function.
      */
     if (!OidIsValid(funcoid))
         funcoid = LookupFuncName(stmt->funcname, 0, NULL, false);
     if (!isInternal)
     {
         aclresult = object_aclcheck(ProcedureRelationId, funcoid, GetUserId(), ACL_EXECUTE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, OBJECT_FUNCTION,
                            NameListToString(stmt->funcname));
     }
     funcrettype = get_func_rettype(funcoid);
     if (funcrettype != TRIGGEROID)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                  errmsg("function %s must return type %s",
                         NameListToString(stmt->funcname), "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.
      */
     tgrel = table_open(TriggerRelationId, RowExclusiveLock);
     if (!isInternal)
     {
         ScanKeyData skeys[2];
         SysScanDesc tgscan;
  
         ScanKeyInit(&skeys[0],
                     Anum_pg_trigger_tgrelid,
                     BTEqualStrategyNumber, F_OIDEQ,
                     ObjectIdGetDatum(RelationGetRelid(rel)));
  
         ScanKeyInit(&skeys[1],
                     Anum_pg_trigger_tgname,
                     BTEqualStrategyNumber, F_NAMEEQ,
                     CStringGetDatum(stmt->trigname));
  
         tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
                                     NULL, 2, skeys);
  
         /* There should be at most one matching tuple */
         if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
         {
             Form_pg_trigger oldtrigger = (Form_pg_trigger) GETSTRUCT(tuple);
  
             trigoid = oldtrigger->oid;
             existing_constraint_oid = oldtrigger->tgconstraint;
             existing_isInternal = oldtrigger->tgisinternal;
             existing_isClone = OidIsValid(oldtrigger->tgparentid);
             trigger_exists = true;
             /* copy the tuple to use in CatalogTupleUpdate() */
             tuple = heap_copytuple(tuple);
         }
         systable_endscan(tgscan);
     }
  
     if (!trigger_exists)
     {
         /* Generate the OID for the new trigger. */
         trigoid = GetNewOidWithIndex(tgrel, TriggerOidIndexId,
                                      Anum_pg_trigger_oid);
     }
     else
     {
         /*
          * If OR REPLACE was specified, we'll replace the old trigger;
          * otherwise complain about the duplicate name.
          */
         if (!stmt->replace)
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("trigger \"%s\" for relation \"%s\" already exists",
                             stmt->trigname, RelationGetRelationName(rel))));
  
         /*
          * 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) &&
             !isInternal && !in_partition)
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("trigger \"%s\" for relation \"%s\" is an internal or a child trigger",
                             stmt->trigname, RelationGetRelationName(rel))));
  
         /*
          * It is not allowed to replace with a constraint trigger; gram.y
          * should have enforced this already.
          */
         Assert(!stmt->isconstraint);
  
         /*
          * 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))
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("trigger \"%s\" for relation \"%s\" is a constraint trigger",
                             stmt->trigname, RelationGetRelationName(rel))));
     }
  
     /*
      * 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 */
         Assert(!isInternal);
         constraintOid = CreateConstraintEntry(stmt->trigname,
                                               RelationGetNamespace(rel),
                                               CONSTRAINT_TRIGGER,
                                               stmt->deferrable,
                                               stmt->initdeferred,
                                               true,
                                               InvalidOid,   /* no parent */
                                               RelationGetRelid(rel),
                                               NULL, /* no conkey */
                                               0,
                                               0,
                                               InvalidOid,   /* no domain */
                                               InvalidOid,   /* no index */
                                               InvalidOid,   /* no foreign key */
                                               NULL,
                                               NULL,
                                               NULL,
                                               NULL,
                                               0,
                                               ' ',
                                               ' ',
                                               NULL,
                                               0,
                                               ' ',
                                               NULL, /* no exclusion */
                                               NULL, /* no check constraint */
                                               NULL,
                                               true, /* islocal */
                                               0,    /* inhcount */
                                               true, /* noinherit */
                                               isInternal);  /* 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)
     {
         snprintf(internaltrigname, sizeof(internaltrigname),
                  "%s_%u", stmt->trigname, trigoid);
         trigname = internaltrigname;
     }
     else
     {
         /* user-defined trigger; use the specified trigger name as-is */
         trigname = stmt->trigname;
     }
  
     /*
      * Build the new pg_trigger tuple.
      *
      * When we're creating a trigger in a partition, we mark it as internal,
      * even though we don't do the isInternal magic in this function.  This
      * makes the triggers in partitions identical to the ones in the
      * partitioned tables, except that they are marked internal.
      */
     memset(nulls, false, sizeof(nulls));
  
     values[Anum_pg_trigger_oid - 1] = ObjectIdGetDatum(trigoid);
     values[Anum_pg_trigger_tgrelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
     values[Anum_pg_trigger_tgparentid - 1] = ObjectIdGetDatum(parentTriggerOid);
     values[Anum_pg_trigger_tgname - 1] = DirectFunctionCall1(namein,
                                                              CStringGetDatum(trigname));
     values[Anum_pg_trigger_tgfoid - 1] = ObjectIdGetDatum(funcoid);
     values[Anum_pg_trigger_tgtype - 1] = Int16GetDatum(tgtype);
     values[Anum_pg_trigger_tgenabled - 1] = trigger_fires_when;
     values[Anum_pg_trigger_tgisinternal - 1] = BoolGetDatum(isInternal);
     values[Anum_pg_trigger_tgconstrrelid - 1] = ObjectIdGetDatum(constrrelid);
     values[Anum_pg_trigger_tgconstrindid - 1] = ObjectIdGetDatum(indexOid);
     values[Anum_pg_trigger_tgconstraint - 1] = ObjectIdGetDatum(constraintOid);
     values[Anum_pg_trigger_tgdeferrable - 1] = BoolGetDatum(stmt->deferrable);
     values[Anum_pg_trigger_tginitdeferred - 1] = BoolGetDatum(stmt->initdeferred);
  
     if (stmt->args)
     {
         ListCell   *le;
         char       *args;
         int16       nargs = list_length(stmt->args);
         int         len = 0;
  
         foreach(le, stmt->args)
         {
             char       *ar = strVal(lfirst(le));
  
             len += strlen(ar) + 4;
             for (; *ar; ar++)
             {
                 if (*ar == '\\')
                     len++;
             }
         }
         args = (char *) palloc(len + 1);
         args[0] = '\0';
         foreach(le, stmt->args)
         {
             char       *s = strVal(lfirst(le));
             char       *d = args + strlen(args);
  
             while (*s)
             {
                 if (*s == '\\')
                     *d++ = '\\';
                 *d++ = *s++;
             }
             strcpy(d, "\\000");
         }
         values[Anum_pg_trigger_tgnargs - 1] = Int16GetDatum(nargs);
         values[Anum_pg_trigger_tgargs - 1] = DirectFunctionCall1(byteain,
                                                                  CStringGetDatum(args));
     }
     else
     {
         values[Anum_pg_trigger_tgnargs - 1] = Int16GetDatum(0);
         values[Anum_pg_trigger_tgargs - 1] = DirectFunctionCall1(byteain,
                                                                  CStringGetDatum(""));
     }
  
     /* build column number array if it's a column-specific trigger */
     ncolumns = list_length(stmt->columns);
     if (ncolumns == 0)
         columns = NULL;
     else
     {
         ListCell   *cell;
         int         i = 0;
  
         columns = (int16 *) palloc(ncolumns * sizeof(int16));
         foreach(cell, stmt->columns)
         {
             char       *name = strVal(lfirst(cell));
             int16       attnum;
             int         j;
  
             /* Lookup column name.  System columns are not allowed */
             attnum = attnameAttNum(rel, name, false);
             if (attnum == InvalidAttrNumber)
                 ereport(ERROR,
                         (errcode(ERRCODE_UNDEFINED_COLUMN),
                          errmsg("column \"%s\" of relation \"%s\" does not exist",
                                 name, RelationGetRelationName(rel))));
  
             /* Check for duplicates */
             for (j = i - 1; j >= 0; j--)
             {
                 if (columns[j] == attnum)
                     ereport(ERROR,
                             (errcode(ERRCODE_DUPLICATE_COLUMN),
                              errmsg("column \"%s\" specified more than once",
                                     name)));
             }
  
             columns[i++] = attnum;
         }
     }
     tgattr = buildint2vector(columns, ncolumns);
     values[Anum_pg_trigger_tgattr - 1] = PointerGetDatum(tgattr);
  
     /* set tgqual if trigger has WHEN clause */
     if (qual)
         values[Anum_pg_trigger_tgqual - 1] = CStringGetTextDatum(qual);
     else
         nulls[Anum_pg_trigger_tgqual - 1] = true;
  
     if (oldtablename)
         values[Anum_pg_trigger_tgoldtable - 1] = DirectFunctionCall1(namein,
                                                                      CStringGetDatum(oldtablename));
     else
         nulls[Anum_pg_trigger_tgoldtable - 1] = true;
     if (newtablename)
         values[Anum_pg_trigger_tgnewtable - 1] = DirectFunctionCall1(namein,
                                                                      CStringGetDatum(newtablename));
     else
         nulls[Anum_pg_trigger_tgnewtable - 1] = true;
  
     /*
      * Insert or replace tuple in pg_trigger.
      */
     if (!trigger_exists)
     {
         tuple = heap_form_tuple(tgrel->rd_att, values, nulls);
         CatalogTupleInsert(tgrel, tuple);
     }
     else
     {
         HeapTuple   newtup;
  
         newtup = heap_form_tuple(tgrel->rd_att, values, nulls);
         CatalogTupleUpdate(tgrel, &tuple->t_self, newtup);
         heap_freetuple(newtup);
     }
  
     heap_freetuple(tuple);      /* free either original or new tuple */
     table_close(tgrel, RowExclusiveLock);
  
     pfree(DatumGetPointer(values[Anum_pg_trigger_tgname - 1]));
     pfree(DatumGetPointer(values[Anum_pg_trigger_tgargs - 1]));
     pfree(DatumGetPointer(values[Anum_pg_trigger_tgattr - 1]));
     if (oldtablename)
         pfree(DatumGetPointer(values[Anum_pg_trigger_tgoldtable - 1]));
     if (newtablename)
         pfree(DatumGetPointer(values[Anum_pg_trigger_tgnewtable - 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.
      */
     pgrel = table_open(RelationRelationId, RowExclusiveLock);
     tuple = SearchSysCacheCopy1(RELOID,
                                 ObjectIdGetDatum(RelationGetRelid(rel)));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "cache lookup failed for relation %u",
              RelationGetRelid(rel));
     if (!((Form_pg_class) GETSTRUCT(tuple))->relhastriggers)
     {
         ((Form_pg_class) GETSTRUCT(tuple))->relhastriggers = true;
  
         CatalogTupleUpdate(pgrel, &tuple->t_self, tuple);
  
         CommandCounterIncrement();
     }
     else
         CacheInvalidateRelcacheByTuple(tuple);
  
     heap_freetuple(tuple);
     table_close(pgrel, RowExclusiveLock);
  
     /*
      * If we're replacing a trigger, flush all the old dependencies before
      * recording new ones.
      */
     if (trigger_exists)
         deleteDependencyRecordsFor(TriggerRelationId, trigoid, true);
  
     /*
      * Record dependencies for trigger.  Always place a normal dependency on
      * the function.
      */
     myself.classId = TriggerRelationId;
     myself.objectId = trigoid;
     myself.objectSubId = 0;
  
     referenced.classId = ProcedureRelationId;
     referenced.objectId = funcoid;
     referenced.objectSubId = 0;
     recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
  
     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.
          */
         referenced.classId = ConstraintRelationId;
         referenced.objectId = constraintOid;
         referenced.objectSubId = 0;
         recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL);
     }
     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.)
          */
         referenced.classId = RelationRelationId;
         referenced.objectId = RelationGetRelid(rel);
         referenced.objectSubId = 0;
         recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
  
         if (OidIsValid(constrrelid))
         {
             referenced.classId = RelationRelationId;
             referenced.objectId = constrrelid;
             referenced.objectSubId = 0;
             recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
         }
         /* Not possible to have an index dependency in this case */
         Assert(!OidIsValid(indexOid));
  
         /*
          * If it's a user-specified constraint trigger, make the constraint
          * internally dependent on the trigger instead of vice versa.
          */
         if (OidIsValid(constraintOid))
         {
             referenced.classId = ConstraintRelationId;
             referenced.objectId = constraintOid;
             referenced.objectSubId = 0;
             recordDependencyOn(&referenced, &myself, DEPENDENCY_INTERNAL);
         }
  
         /*
          * If it's a partition trigger, create the partition dependencies.
          */
         if (OidIsValid(parentTriggerOid))
         {
             ObjectAddressSet(referenced, TriggerRelationId, parentTriggerOid);
             recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_PRI);
             ObjectAddressSet(referenced, RelationRelationId, RelationGetRelid(rel));
             recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_SEC);
         }
     }
  
     /* If column-specific trigger, add normal dependencies on columns */
     if (columns != NULL)
     {
         int         i;
  
         referenced.classId = RelationRelationId;
         referenced.objectId = RelationGetRelid(rel);
         for (i = 0; i < ncolumns; i++)
         {
             referenced.objectSubId = columns[i];
             recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
         }
     }
  
     /*
      * 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)
         recordDependencyOnExpr(&myself, whenClause, whenRtable,
                                DEPENDENCY_NORMAL);
  
     /* Post creation hook for new trigger */
     InvokeObjectPostCreateHookArg(TriggerRelationId, trigoid, 0,
                                   isInternal);
  
     /*
      * Lastly, create the trigger on child relations, if needed.
      */
     if (partition_recurse)
     {
         PartitionDesc partdesc = RelationGetPartitionDesc(rel, true);
         int         i;
         MemoryContext oldcxt,
                     perChildCxt;
  
         perChildCxt = AllocSetContextCreate(CurrentMemoryContext,
                                             "part trig clone",
                                             ALLOCSET_SMALL_SIZES);
  
         /*
          * 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.
          */
         Assert(!OidIsValid(indexOid));
  
         oldcxt = MemoryContextSwitchTo(perChildCxt);
  
         /* Iterate to create the trigger on each existing partition */
         for (i = 0; i < partdesc->nparts; i++)
         {
             CreateTrigStmt *childStmt;
             Relation    childTbl;
             Node       *qual;
  
             childTbl = table_open(partdesc->oids[i], ShareRowExclusiveLock);
  
             /*
              * Initialize our fabricated parse node by copying the original
              * one, then resetting fields that we pass separately.
              */
             childStmt = (CreateTrigStmt *) copyObject(stmt);
             childStmt->funcname = NIL;
             childStmt->whenClause = NULL;
  
             /* If there is a WHEN clause, create a modified copy of it */
             qual = copyObject(whenClause);
             qual = (Node *)
                 map_partition_varattnos((List *) qual, PRS2_OLD_VARNO,
                                         childTbl, rel);
             qual = (Node *)
                 map_partition_varattnos((List *) qual, PRS2_NEW_VARNO,
                                         childTbl, rel);
  
             CreateTriggerFiringOn(childStmt, queryString,
                                   partdesc->oids[i], refRelOid,
                                   InvalidOid, InvalidOid,
                                   funcoid, trigoid, qual,
                                   isInternal, true, trigger_fires_when);
  
             table_close(childTbl, NoLock);
  
             MemoryContextReset(perChildCxt);
         }
  
         MemoryContextSwitchTo(oldcxt);
         MemoryContextDelete(perChildCxt);
     }
  
     /* Keep lock on target rel until end of xact */
     table_close(rel, NoLock);
  
     return myself;
 }

References AccessShareLock, ACL_EXECUTE, ACL_TRIGGER, aclcheck_error(), ACLCHECK_OK, addNSItemToQuery(), addRangeTableEntryForRelation(), ALLOCSET_SMALL_SIZES, AllocSetContextCreate, allowSystemTableMods, generate_unaccent_rules::args, Assert(), assign_expr_collations(), attnameAttNum(), attnum, BoolGetDatum(), BTEqualStrategyNumber, buildint2vector(), byteain(), CacheInvalidateRelcacheByTuple(), CatalogTupleInsert(), CatalogTupleUpdate(), ObjectAddress::classId, CommandCounterIncrement(), copyObject, CreateConstraintEntry(), CStringGetDatum(), CStringGetTextDatum, CurrentMemoryContext, DatumGetPointer(), deleteDependencyRecordsFor(), DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, DEPENDENCY_NORMAL, DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, DirectFunctionCall1, elog(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errdetail(), errdetail_relkind_not_supported(), errhint(), errmsg(), ERROR, EXPR_KIND_TRIGGER_WHEN, find_all_inheritors(), free_parsestate(), CreateTrigStmt::funcname, get_func_rettype(), get_rel_name(), get_rel_relkind(), get_relkind_objtype(), GetNewOidWithIndex(), GETSTRUCT, GetUserId(), has_superclass(), heap_copytuple(), heap_form_tuple(), heap_freetuple(), HeapTupleIsValid, i, Int16GetDatum(), InvalidAttrNumber, InvalidOid, InvokeObjectPostCreateHookArg, TriggerTransition::isNew, IsSystemRelation(), TriggerTransition::isTable, j, len, lfirst, lfirst_node, list_free(), list_length(), Var::location, LockRelationOid(), LookupFuncName(), make_parsestate(), makeAlias(), map_partition_varattnos(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), name, TriggerTransition::name, NAMEDATALEN, namein(), NameListToString(), NameStr, NIL, nodeToString(), NoLock, PartitionDescData::nparts, object_aclcheck(), OBJECT_FUNCTION, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, PartitionDescData::oids, ParseState::p_rtable, ParseState::p_sourcetext, palloc(), parser_errposition(), pfree(), pg_class_aclcheck(), PointerGetDatum(), PRS2_NEW_VARNO, PRS2_OLD_VARNO, pull_var_clause(), RangeVarGetRelid, RelationData::rd_att, RelationData::rd_id, RelationData::rd_rel, recordDependencyOn(), recordDependencyOnExpr(), RelationGetDescr, RelationGetNamespace, RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, RELOID, RowExclusiveLock, ScanKeyInit(), SearchSysCacheCopy1, ShareRowExclusiveLock, snprintf, stmt, strVal, systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), table_openrv(), transformWhereClause(), TupleDescAttr, values, Var::varattno, Var::varno, and CreateTrigStmt::whenClause.

Referenced by CloneRowTriggersToPartition(), and CreateTrigger().

◆ EnableDisableTrigger()

void EnableDisableTrigger	(	Relation	rel,
		const char *	tgname,
		Oid	tgparent,
		char	fires_when,
		bool	skip_system,
		bool	recurse,
		LOCKMODE	lockmode
	)

Definition at line 1732 of file trigger.c.

 {
     Relation    tgrel;
     int         nkeys;
     ScanKeyData keys[2];
     SysScanDesc tgscan;
     HeapTuple   tuple;
     bool        found;
     bool        changed;
  
     /* Scan the relevant entries in pg_triggers */
     tgrel = table_open(TriggerRelationId, RowExclusiveLock);
  
     ScanKeyInit(&keys[0],
                 Anum_pg_trigger_tgrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(rel)));
     if (tgname)
     {
         ScanKeyInit(&keys[1],
                     Anum_pg_trigger_tgname,
                     BTEqualStrategyNumber, F_NAMEEQ,
                     CStringGetDatum(tgname));
         nkeys = 2;
     }
     else
         nkeys = 1;
  
     tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
                                 NULL, nkeys, keys);
  
     found = changed = false;
  
     while (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
     {
         Form_pg_trigger oldtrig = (Form_pg_trigger) GETSTRUCT(tuple);
  
         if (OidIsValid(tgparent) && tgparent != oldtrig->tgparentid)
             continue;
  
         if (oldtrig->tgisinternal)
         {
             /* system trigger ... ok to process? */
             if (skip_system)
                 continue;
             if (!superuser())
                 ereport(ERROR,
                         (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                          errmsg("permission denied: \"%s\" is a system trigger",
                                 NameStr(oldtrig->tgname))));
         }
  
         found = true;
  
         if (oldtrig->tgenabled != fires_when)
         {
             /* need to change this one ... make a copy to scribble on */
             HeapTuple   newtup = heap_copytuple(tuple);
             Form_pg_trigger newtrig = (Form_pg_trigger) GETSTRUCT(newtup);
  
             newtrig->tgenabled = fires_when;
  
             CatalogTupleUpdate(tgrel, &newtup->t_self, newtup);
  
             heap_freetuple(newtup);
  
             changed = 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 &&
             rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
             (TRIGGER_FOR_ROW(oldtrig->tgtype)))
         {
             PartitionDesc partdesc = RelationGetPartitionDesc(rel, true);
             int         i;
  
             for (i = 0; i < partdesc->nparts; i++)
             {
                 Relation    part;
  
                 part = relation_open(partdesc->oids[i], lockmode);
                 /* Match on child triggers' tgparentid, not their name */
                 EnableDisableTrigger(part, NULL, oldtrig->oid,
                                      fires_when, skip_system, recurse,
                                      lockmode);
                 table_close(part, NoLock);  /* keep lock till commit */
             }
         }
  
         InvokeObjectPostAlterHook(TriggerRelationId,
                                   oldtrig->oid, 0);
     }
  
     systable_endscan(tgscan);
  
     table_close(tgrel, RowExclusiveLock);
  
     if (tgname && !found)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("trigger \"%s\" for table \"%s\" does not exist",
                         tgname, RelationGetRelationName(rel))));
  
     /*
      * 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)
         CacheInvalidateRelcache(rel);
 }

References BTEqualStrategyNumber, CacheInvalidateRelcache(), CatalogTupleUpdate(), CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_copytuple(), heap_freetuple(), HeapTupleIsValid, i, InvokeObjectPostAlterHook, NameStr, NoLock, PartitionDescData::nparts, ObjectIdGetDatum(), OidIsValid, PartitionDescData::oids, RelationData::rd_rel, relation_open(), RelationGetPartitionDesc(), RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), superuser(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecEnableDisableTrigger().

◆ ExecARDeleteTriggers()

void ExecARDeleteTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		ItemPointer	tupleid,
		HeapTuple	fdw_trigtuple,
		TransitionCaptureState *	transition_capture,
		bool	is_crosspart_update
	)

Definition at line 2785 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
  
     if ((trigdesc && trigdesc->trig_delete_after_row) ||
         (transition_capture && transition_capture->tcs_delete_old_table))
     {
         TupleTableSlot *slot = ExecGetTriggerOldSlot(estate, relinfo);
  
         Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
         if (fdw_trigtuple == NULL)
             GetTupleForTrigger(estate,
                                NULL,
                                relinfo,
                                tupleid,
                                LockTupleExclusive,
                                slot,
                                NULL,
                                NULL,
                                NULL);
         else
             ExecForceStoreHeapTuple(fdw_trigtuple, slot, false);
  
         AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
                               TRIGGER_EVENT_DELETE,
                               true, slot, NULL, NIL, NULL,
                               transition_capture,
                               is_crosspart_update);
     }
 }

References AfterTriggerSaveEvent(), Assert(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), GetTupleForTrigger(), HeapTupleIsValid, ItemPointerIsValid(), LockTupleExclusive, NIL, ResultRelInfo::ri_TrigDesc, TransitionCaptureState::tcs_delete_old_table, TriggerDesc::trig_delete_after_row, and TRIGGER_EVENT_DELETE.

Referenced by ExecDeleteEpilogue(), and ExecSimpleRelationDelete().

◆ ExecARInsertTriggers()

void ExecARInsertTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		TupleTableSlot *	slot,
		List *	recheckIndexes,
		TransitionCaptureState *	transition_capture
	)

Definition at line 2545 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
  
     if ((trigdesc && trigdesc->trig_insert_after_row) ||
         (transition_capture && transition_capture->tcs_insert_new_table))
         AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
                               TRIGGER_EVENT_INSERT,
                               true, NULL, slot,
                               recheckIndexes, NULL,
                               transition_capture,
                               false);
 }

References AfterTriggerSaveEvent(), ResultRelInfo::ri_TrigDesc, TransitionCaptureState::tcs_insert_new_table, TriggerDesc::trig_insert_after_row, and TRIGGER_EVENT_INSERT.

Referenced by CopyFrom(), CopyMultiInsertBufferFlush(), ExecBatchInsert(), ExecInsert(), and ExecSimpleRelationInsert().

◆ ExecARUpdateTriggers()

void ExecARUpdateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		ResultRelInfo *	src_partinfo,
		ResultRelInfo *	dst_partinfo,
		ItemPointer	tupleid,
		HeapTuple	fdw_trigtuple,
		TupleTableSlot *	newslot,
		List *	recheckIndexes,
		TransitionCaptureState *	transition_capture,
		bool	is_crosspart_update
	)

Definition at line 3090 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
  
     if ((trigdesc && trigdesc->trig_update_after_row) ||
         (transition_capture &&
          (transition_capture->tcs_update_old_table ||
           transition_capture->tcs_update_new_table)))
     {
         /*
          * 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.
          */
         TupleTableSlot *oldslot;
         ResultRelInfo *tupsrc;
  
         Assert((src_partinfo != NULL && dst_partinfo != NULL) ||
                !is_crosspart_update);
  
         tupsrc = src_partinfo ? src_partinfo : relinfo;
         oldslot = ExecGetTriggerOldSlot(estate, tupsrc);
  
         if (fdw_trigtuple == NULL && ItemPointerIsValid(tupleid))
             GetTupleForTrigger(estate,
                                NULL,
                                tupsrc,
                                tupleid,
                                LockTupleExclusive,
                                oldslot,
                                NULL,
                                NULL,
                                NULL);
         else if (fdw_trigtuple != NULL)
             ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, false);
         else
             ExecClearTuple(oldslot);
  
         AfterTriggerSaveEvent(estate, relinfo,
                               src_partinfo, dst_partinfo,
                               TRIGGER_EVENT_UPDATE,
                               true,
                               oldslot, newslot, recheckIndexes,
                               ExecGetAllUpdatedCols(relinfo, estate),
                               transition_capture,
                               is_crosspart_update);
     }
 }

References AfterTriggerSaveEvent(), Assert(), ExecClearTuple(), ExecForceStoreHeapTuple(), ExecGetAllUpdatedCols(), ExecGetTriggerOldSlot(), GetTupleForTrigger(), ItemPointerIsValid(), LockTupleExclusive, ResultRelInfo::ri_TrigDesc, TransitionCaptureState::tcs_update_new_table, TransitionCaptureState::tcs_update_old_table, TriggerDesc::trig_update_after_row, and TRIGGER_EVENT_UPDATE.

Referenced by ExecCrossPartitionUpdateForeignKey(), ExecDeleteEpilogue(), ExecInsert(), ExecSimpleRelationUpdate(), and ExecUpdateEpilogue().

◆ ExecASDeleteTriggers()

void ExecASDeleteTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		TransitionCaptureState *	transition_capture
	)

Definition at line 2674 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
  
     if (trigdesc && trigdesc->trig_delete_after_statement)
         AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
                               TRIGGER_EVENT_DELETE,
                               false, NULL, NULL, NIL, NULL, transition_capture,
                               false);
 }

References AfterTriggerSaveEvent(), NIL, ResultRelInfo::ri_TrigDesc, TriggerDesc::trig_delete_after_statement, and TRIGGER_EVENT_DELETE.

Referenced by fireASTriggers().

◆ ExecASInsertTriggers()

void ExecASInsertTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		TransitionCaptureState *	transition_capture
	)

Definition at line 2456 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
  
     if (trigdesc && trigdesc->trig_insert_after_statement)
         AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
                               TRIGGER_EVENT_INSERT,
                               false, NULL, NULL, NIL, NULL, transition_capture,
                               false);
 }

References AfterTriggerSaveEvent(), NIL, ResultRelInfo::ri_TrigDesc, TriggerDesc::trig_insert_after_statement, and TRIGGER_EVENT_INSERT.

Referenced by CopyFrom(), and fireASTriggers().

◆ ExecASTruncateTriggers()

void ExecASTruncateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 3262 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
  
     if (trigdesc && trigdesc->trig_truncate_after_statement)
         AfterTriggerSaveEvent(estate, relinfo,
                               NULL, NULL,
                               TRIGGER_EVENT_TRUNCATE,
                               false, NULL, NULL, NIL, NULL, NULL,
                               false);
 }

References AfterTriggerSaveEvent(), NIL, ResultRelInfo::ri_TrigDesc, TriggerDesc::trig_truncate_after_statement, and TRIGGER_EVENT_TRUNCATE.

Referenced by ExecuteTruncateGuts().

◆ ExecASUpdateTriggers()

void ExecASUpdateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		TransitionCaptureState *	transition_capture
	)

Definition at line 2927 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
  
     /* statement-level triggers operate on the parent table */
     Assert(relinfo->ri_RootResultRelInfo == NULL);
  
     if (trigdesc && trigdesc->trig_update_after_statement)
         AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
                               TRIGGER_EVENT_UPDATE,
                               false, NULL, NULL, NIL,
                               ExecGetAllUpdatedCols(relinfo, estate),
                               transition_capture,
                               false);
 }

References AfterTriggerSaveEvent(), Assert(), ExecGetAllUpdatedCols(), NIL, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_TrigDesc, TriggerDesc::trig_update_after_statement, and TRIGGER_EVENT_UPDATE.

Referenced by fireASTriggers().

◆ ExecBRDeleteTriggers()

bool ExecBRDeleteTriggers	(	EState *	estate,
		EPQState *	epqstate,
		ResultRelInfo *	relinfo,
		ItemPointer	tupleid,
		HeapTuple	fdw_trigtuple,
		TupleTableSlot **	epqslot,
		TM_Result *	tmresult,
		TM_FailureData *	tmfd
	)

Definition at line 2694 of file trigger.c.

 {
     TupleTableSlot *slot = ExecGetTriggerOldSlot(estate, relinfo);
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     bool        result = true;
     TriggerData LocTriggerData = {0};
     HeapTuple   trigtuple;
     bool        should_free = false;
     int         i;
  
     Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
     if (fdw_trigtuple == NULL)
     {
         TupleTableSlot *epqslot_candidate = NULL;
  
         if (!GetTupleForTrigger(estate, epqstate, relinfo, tupleid,
                                 LockTupleExclusive, slot, &epqslot_candidate,
                                 tmresult, tmfd))
             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)
         {
             *epqslot = epqslot_candidate;
             return false;
         }
  
         trigtuple = ExecFetchSlotHeapTuple(slot, true, &should_free);
     }
     else
     {
         trigtuple = fdw_trigtuple;
         ExecForceStoreHeapTuple(trigtuple, slot, false);
     }
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_DELETE |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         HeapTuple   newtuple;
         Trigger    *trigger = &trigdesc->triggers[i];
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_ROW,
                                   TRIGGER_TYPE_BEFORE,
                                   TRIGGER_TYPE_DELETE))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             NULL, slot, NULL))
             continue;
  
         LocTriggerData.tg_trigslot = slot;
         LocTriggerData.tg_trigtuple = trigtuple;
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
         if (newtuple == NULL)
         {
             result = false;     /* tell caller to suppress delete */
             break;
         }
         if (newtuple != trigtuple)
             heap_freetuple(newtuple);
     }
     if (should_free)
         heap_freetuple(trigtuple);
  
     return result;
 }

References Assert(), ExecCallTriggerFunc(), ExecFetchSlotHeapTuple(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), GetPerTupleMemoryContext, GetTupleForTrigger(), heap_freetuple(), HeapTupleIsValid, i, ItemPointerIsValid(), LockTupleExclusive, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigslot, TriggerData::tg_trigtuple, Trigger::tgtype, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_DELETE, TRIGGER_EVENT_ROW, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by ExecDeletePrologue(), and ExecSimpleRelationDelete().

◆ ExecBRInsertTriggers()

bool ExecBRInsertTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		TupleTableSlot *	slot
	)

Definition at line 2469 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     HeapTuple   newtuple = NULL;
     bool        should_free;
     TriggerData LocTriggerData = {0};
     int         i;
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_INSERT |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
         HeapTuple   oldtuple;
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_ROW,
                                   TRIGGER_TYPE_BEFORE,
                                   TRIGGER_TYPE_INSERT))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             NULL, NULL, slot))
             continue;
  
         if (!newtuple)
             newtuple = ExecFetchSlotHeapTuple(slot, true, &should_free);
  
         LocTriggerData.tg_trigslot = slot;
         LocTriggerData.tg_trigtuple = oldtuple = newtuple;
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
         if (newtuple == NULL)
         {
             if (should_free)
                 heap_freetuple(oldtuple);
             return false;       /* "do nothing" */
         }
         else if (newtuple != oldtuple)
         {
             ExecForceStoreHeapTuple(newtuple, slot, 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 &&
                 !ExecPartitionCheck(relinfo, slot, estate, false))
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("moving row to another partition during a BEFORE FOR EACH ROW trigger is not supported"),
                          errdetail("Before executing trigger \"%s\", the row was to be in partition \"%s.%s\".",
                                    trigger->tgname,
                                    get_namespace_name(RelationGetNamespace(relinfo->ri_RelationDesc)),
                                    RelationGetRelationName(relinfo->ri_RelationDesc))));
  
             if (should_free)
                 heap_freetuple(oldtuple);
  
             /* signal tuple should be re-fetched if used */
             newtuple = NULL;
         }
     }
  
     return true;
 }

References ereport, errcode(), errdetail(), errmsg(), ERROR, ExecCallTriggerFunc(), ExecFetchSlotHeapTuple(), ExecForceStoreHeapTuple(), ExecPartitionCheck(), get_namespace_name(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, RelationGetNamespace, RelationGetRelationName, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigslot, TriggerData::tg_trigtuple, Trigger::tgisclone, Trigger::tgname, Trigger::tgtype, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_INSERT, TRIGGER_EVENT_ROW, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by CopyFrom(), ExecInsert(), and ExecSimpleRelationInsert().

◆ ExecBRUpdateTriggers()

bool ExecBRUpdateTriggers	(	EState *	estate,
		EPQState *	epqstate,
		ResultRelInfo *	relinfo,
		ItemPointer	tupleid,
		HeapTuple	fdw_trigtuple,
		TupleTableSlot *	newslot,
		TM_Result *	tmresult,
		TM_FailureData *	tmfd
	)

Definition at line 2945 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     TupleTableSlot *oldslot = ExecGetTriggerOldSlot(estate, relinfo);
     HeapTuple   newtuple = NULL;
     HeapTuple   trigtuple;
     bool        should_free_trig = false;
     bool        should_free_new = false;
     TriggerData LocTriggerData = {0};
     int         i;
     Bitmapset  *updatedCols;
     LockTupleMode lockmode;
  
     /* Determine lock mode to use */
     lockmode = ExecUpdateLockMode(estate, relinfo);
  
     Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
     if (fdw_trigtuple == NULL)
     {
         TupleTableSlot *epqslot_candidate = NULL;
  
         /* get a copy of the on-disk tuple we are planning to update */
         if (!GetTupleForTrigger(estate, epqstate, relinfo, tupleid,
                                 lockmode, oldslot, &epqslot_candidate,
                                 tmresult, tmfd))
             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.
          *
          * (Typically, newslot was also generated by ExecGetUpdateNewTuple, so
          * that epqslot_clean will be that same slot and the copy step below
          * is not needed.)
          */
         if (epqslot_candidate != NULL)
         {
             TupleTableSlot *epqslot_clean;
  
             epqslot_clean = ExecGetUpdateNewTuple(relinfo, epqslot_candidate,
                                                   oldslot);
  
             if (newslot != epqslot_clean)
                 ExecCopySlot(newslot, epqslot_clean);
         }
  
         trigtuple = ExecFetchSlotHeapTuple(oldslot, true, &should_free_trig);
     }
     else
     {
         ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, false);
         trigtuple = fdw_trigtuple;
     }
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_UPDATE |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     updatedCols = ExecGetAllUpdatedCols(relinfo, estate);
     LocTriggerData.tg_updatedcols = updatedCols;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
         HeapTuple   oldtuple;
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_ROW,
                                   TRIGGER_TYPE_BEFORE,
                                   TRIGGER_TYPE_UPDATE))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             updatedCols, oldslot, newslot))
             continue;
  
         if (!newtuple)
             newtuple = ExecFetchSlotHeapTuple(newslot, true, &should_free_new);
  
         LocTriggerData.tg_trigslot = oldslot;
         LocTriggerData.tg_trigtuple = trigtuple;
         LocTriggerData.tg_newtuple = oldtuple = newtuple;
         LocTriggerData.tg_newslot = newslot;
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
  
         if (newtuple == NULL)
         {
             if (should_free_trig)
                 heap_freetuple(trigtuple);
             if (should_free_new)
                 heap_freetuple(oldtuple);
             return false;       /* "do nothing" */
         }
         else if (newtuple != oldtuple)
         {
             ExecForceStoreHeapTuple(newtuple, newslot, 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)
                 ExecMaterializeSlot(newslot);
  
             if (should_free_new)
                 heap_freetuple(oldtuple);
  
             /* signal tuple should be re-fetched if used */
             newtuple = NULL;
         }
     }
     if (should_free_trig)
         heap_freetuple(trigtuple);
  
     return true;
 }

References Assert(), ExecCallTriggerFunc(), ExecCopySlot(), ExecFetchSlotHeapTuple(), ExecForceStoreHeapTuple(), ExecGetAllUpdatedCols(), ExecGetTriggerOldSlot(), ExecGetUpdateNewTuple(), ExecMaterializeSlot(), ExecUpdateLockMode(), GetPerTupleMemoryContext, GetTupleForTrigger(), heap_freetuple(), HeapTupleIsValid, i, ItemPointerIsValid(), TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_newslot, TriggerData::tg_newtuple, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigslot, TriggerData::tg_trigtuple, TriggerData::tg_updatedcols, Trigger::tgtype, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_ROW, TRIGGER_EVENT_UPDATE, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by ExecSimpleRelationUpdate(), and ExecUpdatePrologue().

◆ ExecBSDeleteTriggers()

void ExecBSDeleteTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2623 of file trigger.c.

 {
     TriggerDesc *trigdesc;
     int         i;
     TriggerData LocTriggerData = {0};
  
     trigdesc = relinfo->ri_TrigDesc;
  
     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),
                                    CMD_DELETE))
         return;
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_DELETE |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
         HeapTuple   newtuple;
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_STATEMENT,
                                   TRIGGER_TYPE_BEFORE,
                                   TRIGGER_TYPE_DELETE))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             NULL, NULL, NULL))
             continue;
  
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
  
         if (newtuple)
             ereport(ERROR,
                     (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
                      errmsg("BEFORE STATEMENT trigger cannot return a value")));
     }
 }

References before_stmt_triggers_fired(), CMD_DELETE, ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, RelationGetRelid, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_relation, TriggerData::tg_trigger, Trigger::tgtype, TriggerDesc::trig_delete_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_DELETE, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by fireBSTriggers().

◆ ExecBSInsertTriggers()

void ExecBSInsertTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2405 of file trigger.c.

 {
     TriggerDesc *trigdesc;
     int         i;
     TriggerData LocTriggerData = {0};
  
     trigdesc = relinfo->ri_TrigDesc;
  
     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),
                                    CMD_INSERT))
         return;
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_INSERT |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
         HeapTuple   newtuple;
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_STATEMENT,
                                   TRIGGER_TYPE_BEFORE,
                                   TRIGGER_TYPE_INSERT))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             NULL, NULL, NULL))
             continue;
  
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
  
         if (newtuple)
             ereport(ERROR,
                     (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
                      errmsg("BEFORE STATEMENT trigger cannot return a value")));
     }
 }

References before_stmt_triggers_fired(), CMD_INSERT, ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, RelationGetRelid, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_relation, TriggerData::tg_trigger, Trigger::tgtype, TriggerDesc::trig_insert_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_INSERT, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by CopyFrom(), and fireBSTriggers().

◆ ExecBSTruncateTriggers()

void ExecBSTruncateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 3215 of file trigger.c.

 {
     TriggerDesc *trigdesc;
     int         i;
     TriggerData LocTriggerData = {0};
  
     trigdesc = relinfo->ri_TrigDesc;
  
     if (trigdesc == NULL)
         return;
     if (!trigdesc->trig_truncate_before_statement)
         return;
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_TRUNCATE |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
  
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
         HeapTuple   newtuple;
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_STATEMENT,
                                   TRIGGER_TYPE_BEFORE,
                                   TRIGGER_TYPE_TRUNCATE))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             NULL, NULL, NULL))
             continue;
  
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
  
         if (newtuple)
             ereport(ERROR,
                     (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
                      errmsg("BEFORE STATEMENT trigger cannot return a value")));
     }
 }

References ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_relation, TriggerData::tg_trigger, Trigger::tgtype, TriggerDesc::trig_truncate_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_TRUNCATE, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by ExecuteTruncateGuts().

◆ ExecBSUpdateTriggers()

void ExecBSUpdateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2869 of file trigger.c.

 {
     TriggerDesc *trigdesc;
     int         i;
     TriggerData LocTriggerData = {0};
     Bitmapset  *updatedCols;
  
     trigdesc = relinfo->ri_TrigDesc;
  
     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),
                                    CMD_UPDATE))
         return;
  
     /* statement-level triggers operate on the parent table */
     Assert(relinfo->ri_RootResultRelInfo == NULL);
  
     updatedCols = ExecGetAllUpdatedCols(relinfo, estate);
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_UPDATE |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     LocTriggerData.tg_updatedcols = updatedCols;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
         HeapTuple   newtuple;
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_STATEMENT,
                                   TRIGGER_TYPE_BEFORE,
                                   TRIGGER_TYPE_UPDATE))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             updatedCols, NULL, NULL))
             continue;
  
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
  
         if (newtuple)
             ereport(ERROR,
                     (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
                      errmsg("BEFORE STATEMENT trigger cannot return a value")));
     }
 }

References Assert(), before_stmt_triggers_fired(), CMD_UPDATE, ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), ExecGetAllUpdatedCols(), GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, RelationGetRelid, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_updatedcols, Trigger::tgtype, TriggerDesc::trig_update_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_UPDATE, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by fireBSTriggers().

◆ ExecIRDeleteTriggers()

bool ExecIRDeleteTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		HeapTuple	trigtuple
	)

Definition at line 2822 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     TupleTableSlot *slot = ExecGetTriggerOldSlot(estate, relinfo);
     TriggerData LocTriggerData = {0};
     int         i;
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_DELETE |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_INSTEAD;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
  
     ExecForceStoreHeapTuple(trigtuple, slot, false);
  
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         HeapTuple   rettuple;
         Trigger    *trigger = &trigdesc->triggers[i];
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_ROW,
                                   TRIGGER_TYPE_INSTEAD,
                                   TRIGGER_TYPE_DELETE))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             NULL, slot, NULL))
             continue;
  
         LocTriggerData.tg_trigslot = slot;
         LocTriggerData.tg_trigtuple = trigtuple;
         LocTriggerData.tg_trigger = trigger;
         rettuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
         if (rettuple == NULL)
             return false;       /* Delete was suppressed */
         if (rettuple != trigtuple)
             heap_freetuple(rettuple);
     }
     return true;
 }

References ExecCallTriggerFunc(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigslot, TriggerData::tg_trigtuple, Trigger::tgtype, TRIGGER_EVENT_DELETE, TRIGGER_EVENT_INSTEAD, TRIGGER_EVENT_ROW, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by ExecDelete().

◆ ExecIRInsertTriggers()

bool ExecIRInsertTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		TupleTableSlot *	slot
	)

Definition at line 2562 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     HeapTuple   newtuple = NULL;
     bool        should_free;
     TriggerData LocTriggerData = {0};
     int         i;
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_INSERT |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_INSTEAD;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
         HeapTuple   oldtuple;
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_ROW,
                                   TRIGGER_TYPE_INSTEAD,
                                   TRIGGER_TYPE_INSERT))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             NULL, NULL, slot))
             continue;
  
         if (!newtuple)
             newtuple = ExecFetchSlotHeapTuple(slot, true, &should_free);
  
         LocTriggerData.tg_trigslot = slot;
         LocTriggerData.tg_trigtuple = oldtuple = newtuple;
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
         if (newtuple == NULL)
         {
             if (should_free)
                 heap_freetuple(oldtuple);
             return false;       /* "do nothing" */
         }
         else if (newtuple != oldtuple)
         {
             ExecForceStoreHeapTuple(newtuple, slot, false);
  
             if (should_free)
                 heap_freetuple(oldtuple);
  
             /* signal tuple should be re-fetched if used */
             newtuple = NULL;
         }
     }
  
     return true;
 }

References ExecCallTriggerFunc(), ExecFetchSlotHeapTuple(), ExecForceStoreHeapTuple(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigslot, TriggerData::tg_trigtuple, Trigger::tgtype, TRIGGER_EVENT_INSERT, TRIGGER_EVENT_INSTEAD, TRIGGER_EVENT_ROW, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by CopyFrom(), and ExecInsert().

◆ ExecIRUpdateTriggers()

bool ExecIRUpdateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		HeapTuple	trigtuple,
		TupleTableSlot *	newslot
	)

Definition at line 3149 of file trigger.c.

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     TupleTableSlot *oldslot = ExecGetTriggerOldSlot(estate, relinfo);
     HeapTuple   newtuple = NULL;
     bool        should_free;
     TriggerData LocTriggerData = {0};
     int         i;
  
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_UPDATE |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_INSTEAD;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
  
     ExecForceStoreHeapTuple(trigtuple, oldslot, false);
  
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
         HeapTuple   oldtuple;
  
         if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
                                   TRIGGER_TYPE_ROW,
                                   TRIGGER_TYPE_INSTEAD,
                                   TRIGGER_TYPE_UPDATE))
             continue;
         if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
                             NULL, oldslot, newslot))
             continue;
  
         if (!newtuple)
             newtuple = ExecFetchSlotHeapTuple(newslot, true, &should_free);
  
         LocTriggerData.tg_trigslot = oldslot;
         LocTriggerData.tg_trigtuple = trigtuple;
         LocTriggerData.tg_newslot = newslot;
         LocTriggerData.tg_newtuple = oldtuple = newtuple;
  
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
         if (newtuple == NULL)
         {
             return false;       /* "do nothing" */
         }
         else if (newtuple != oldtuple)
         {
             ExecForceStoreHeapTuple(newtuple, newslot, false);
  
             if (should_free)
                 heap_freetuple(oldtuple);
  
             /* signal tuple should be re-fetched if used */
             newtuple = NULL;
         }
     }
  
     return true;
 }

References ExecCallTriggerFunc(), ExecFetchSlotHeapTuple(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, TriggerData::tg_event, TriggerData::tg_newslot, TriggerData::tg_newtuple, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigslot, TriggerData::tg_trigtuple, Trigger::tgtype, TRIGGER_EVENT_INSTEAD, TRIGGER_EVENT_ROW, TRIGGER_EVENT_UPDATE, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by ExecUpdate().

◆ FindTriggerIncompatibleWithInheritance()

const char* FindTriggerIncompatibleWithInheritance ( TriggerDesc * trigdesc )

Definition at line 2283 of file trigger.c.

 {
     if (trigdesc != NULL)
     {
         int         i;
  
         for (i = 0; i < trigdesc->numtriggers; ++i)
         {
             Trigger    *trigger = &trigdesc->triggers[i];
  
             if (trigger->tgoldtable != NULL || trigger->tgnewtable != NULL)
                 return trigger->tgname;
         }
     }
  
     return NULL;
 }

References i, TriggerDesc::numtriggers, Trigger::tgname, Trigger::tgnewtable, Trigger::tgoldtable, and TriggerDesc::triggers.

Referenced by ATExecAddInherit(), and ATExecAttachPartition().

◆ FreeTriggerDesc()

void FreeTriggerDesc ( TriggerDesc * trigdesc )

Definition at line 2151 of file trigger.c.

 {
     Trigger    *trigger;
     int         i;
  
     if (trigdesc == NULL)
         return;
  
     trigger = trigdesc->triggers;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         pfree(trigger->tgname);
         if (trigger->tgnattr > 0)
             pfree(trigger->tgattr);
         if (trigger->tgnargs > 0)
         {
             while (--(trigger->tgnargs) >= 0)
                 pfree(trigger->tgargs[trigger->tgnargs]);
             pfree(trigger->tgargs);
         }
         if (trigger->tgqual)
             pfree(trigger->tgqual);
         if (trigger->tgoldtable)
             pfree(trigger->tgoldtable);
         if (trigger->tgnewtable)
             pfree(trigger->tgnewtable);
         trigger++;
     }
     pfree(trigdesc->triggers);
     pfree(trigdesc);
 }

References i, TriggerDesc::numtriggers, pfree(), Trigger::tgargs, Trigger::tgattr, Trigger::tgname, Trigger::tgnargs, Trigger::tgnattr, Trigger::tgnewtable, Trigger::tgoldtable, Trigger::tgqual, and TriggerDesc::triggers.

Referenced by RelationBuildTriggers(), and RelationDestroyRelation().

◆ get_trigger_oid()

Oid get_trigger_oid	(	Oid	relid,
		const char *	trigname,
		bool	missing_ok
	)

Definition at line 1377 of file trigger.c.

 {
     Relation    tgrel;
     ScanKeyData skey[2];
     SysScanDesc tgscan;
     HeapTuple   tup;
     Oid         oid;
  
     /*
      * Find the trigger, verify permissions, set up object address
      */
     tgrel = table_open(TriggerRelationId, AccessShareLock);
  
     ScanKeyInit(&skey[0],
                 Anum_pg_trigger_tgrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(relid));
     ScanKeyInit(&skey[1],
                 Anum_pg_trigger_tgname,
                 BTEqualStrategyNumber, F_NAMEEQ,
                 CStringGetDatum(trigname));
  
     tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
                                 NULL, 2, skey);
  
     tup = systable_getnext(tgscan);
  
     if (!HeapTupleIsValid(tup))
     {
         if (!missing_ok)
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("trigger \"%s\" for table \"%s\" does not exist",
                             trigname, get_rel_name(relid))));
         oid = InvalidOid;
     }
     else
     {
         oid = ((Form_pg_trigger) GETSTRUCT(tup))->oid;
     }
  
     systable_endscan(tgscan);
     table_close(tgrel, AccessShareLock);
     return oid;
 }

References AccessShareLock, BTEqualStrategyNumber, CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, get_rel_name(), GETSTRUCT, HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by get_object_address_relobject().

◆ MakeTransitionCaptureState()

TransitionCaptureState* MakeTransitionCaptureState	(	TriggerDesc *	trigdesc,
		Oid	relid,
		CmdType	cmdType
	)

Definition at line 4844 of file trigger.c.

 {
     TransitionCaptureState *state;
     bool        need_old_upd,
                 need_new_upd,
                 need_old_del,
                 need_new_ins;
     AfterTriggersTableData *table;
     MemoryContext oldcxt;
     ResourceOwner saveResourceOwner;
  
     if (trigdesc == NULL)
         return NULL;
  
     /* Detect which table(s) we need. */
     switch (cmdType)
     {
         case CMD_INSERT:
             need_old_upd = need_old_del = need_new_upd = false;
             need_new_ins = trigdesc->trig_insert_new_table;
             break;
         case CMD_UPDATE:
             need_old_upd = trigdesc->trig_update_old_table;
             need_new_upd = trigdesc->trig_update_new_table;
             need_old_del = need_new_ins = false;
             break;
         case CMD_DELETE:
             need_old_del = trigdesc->trig_delete_old_table;
             need_old_upd = need_new_upd = need_new_ins = false;
             break;
         case CMD_MERGE:
             need_old_upd = trigdesc->trig_update_old_table;
             need_new_upd = trigdesc->trig_update_new_table;
             need_old_del = trigdesc->trig_delete_old_table;
             need_new_ins = trigdesc->trig_insert_new_table;
             break;
         default:
             elog(ERROR, "unexpected CmdType: %d", (int) cmdType);
             /* keep compiler quiet */
             need_old_upd = need_new_upd = need_old_del = need_new_ins = 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)
         elog(ERROR, "MakeTransitionCaptureState() called outside of query");
  
     /* Be sure we have enough space to record events at this query depth. */
     if (afterTriggers.query_depth >= afterTriggers.maxquerydepth)
         AfterTriggerEnlargeQueryState();
  
     /*
      * Find or create an AfterTriggersTableData struct to hold the
      * tuplestore(s).  If there's a matching struct but it's marked closed,
      * ignore it; we need a newer one.
      *
      * 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.
      */
     table = GetAfterTriggersTableData(relid, cmdType);
  
     /* Now create required tuplestore(s), if we don't have them already. */
     oldcxt = MemoryContextSwitchTo(CurTransactionContext);
     saveResourceOwner = CurrentResourceOwner;
     CurrentResourceOwner = CurTransactionResourceOwner;
  
     if (need_old_upd && table->old_upd_tuplestore == NULL)
         table->old_upd_tuplestore = tuplestore_begin_heap(false, false, work_mem);
     if (need_new_upd && table->new_upd_tuplestore == NULL)
         table->new_upd_tuplestore = tuplestore_begin_heap(false, false, work_mem);
     if (need_old_del && table->old_del_tuplestore == NULL)
         table->old_del_tuplestore = tuplestore_begin_heap(false, false, work_mem);
     if (need_new_ins && table->new_ins_tuplestore == NULL)
         table->new_ins_tuplestore = tuplestore_begin_heap(false, false, work_mem);
  
     CurrentResourceOwner = saveResourceOwner;
     MemoryContextSwitchTo(oldcxt);
  
     /* Now build the TransitionCaptureState struct, in caller's context */
     state = (TransitionCaptureState *) palloc0(sizeof(TransitionCaptureState));
     state->tcs_delete_old_table = trigdesc->trig_delete_old_table;
     state->tcs_update_old_table = trigdesc->trig_update_old_table;
     state->tcs_update_new_table = trigdesc->trig_update_new_table;
     state->tcs_insert_new_table = trigdesc->trig_insert_new_table;
     state->tcs_private = table;
  
     return state;
 }

References AfterTriggerEnlargeQueryState(), afterTriggers, CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_UPDATE, CurrentResourceOwner, CurTransactionContext, CurTransactionResourceOwner, elog(), ERROR, GetAfterTriggersTableData(), AfterTriggersData::maxquerydepth, MemoryContextSwitchTo(), AfterTriggersTableData::new_ins_tuplestore, AfterTriggersTableData::new_upd_tuplestore, AfterTriggersTableData::old_del_tuplestore, AfterTriggersTableData::old_upd_tuplestore, palloc0(), AfterTriggersData::query_depth, TriggerDesc::trig_delete_old_table, TriggerDesc::trig_insert_new_table, TriggerDesc::trig_update_new_table, TriggerDesc::trig_update_old_table, tuplestore_begin_heap(), and work_mem.

Referenced by CopyFrom(), and ExecSetupTransitionCaptureState().

◆ RelationBuildTriggers()

void RelationBuildTriggers ( Relation relation )

Definition at line 1867 of file trigger.c.

 {
     TriggerDesc *trigdesc;
     int         numtrigs;
     int         maxtrigs;
     Trigger    *triggers;
     Relation    tgrel;
     ScanKeyData skey;
     SysScanDesc tgscan;
     HeapTuple   htup;
     MemoryContext oldContext;
     int         i;
  
     /*
      * Allocate a working array to hold the triggers (the array is extended if
      * necessary)
      */
     maxtrigs = 16;
     triggers = (Trigger *) palloc(maxtrigs * sizeof(Trigger));
     numtrigs = 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.
      */
     ScanKeyInit(&skey,
                 Anum_pg_trigger_tgrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(relation)));
  
     tgrel = table_open(TriggerRelationId, AccessShareLock);
     tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
                                 NULL, 1, &skey);
  
     while (HeapTupleIsValid(htup = systable_getnext(tgscan)))
     {
         Form_pg_trigger pg_trigger = (Form_pg_trigger) GETSTRUCT(htup);
         Trigger    *build;
         Datum       datum;
         bool        isnull;
  
         if (numtrigs >= maxtrigs)
         {
             maxtrigs *= 2;
             triggers = (Trigger *) repalloc(triggers, maxtrigs * sizeof(Trigger));
         }
         build = &(triggers[numtrigs]);
  
         build->tgoid = pg_trigger->oid;
         build->tgname = DatumGetCString(DirectFunctionCall1(nameout,
                                                             NameGetDatum(&pg_trigger->tgname)));
         build->tgfoid = pg_trigger->tgfoid;
         build->tgtype = pg_trigger->tgtype;
         build->tgenabled = pg_trigger->tgenabled;
         build->tgisinternal = pg_trigger->tgisinternal;
         build->tgisclone = OidIsValid(pg_trigger->tgparentid);
         build->tgconstrrelid = pg_trigger->tgconstrrelid;
         build->tgconstrindid = pg_trigger->tgconstrindid;
         build->tgconstraint = pg_trigger->tgconstraint;
         build->tgdeferrable = pg_trigger->tgdeferrable;
         build->tginitdeferred = pg_trigger->tginitdeferred;
         build->tgnargs = pg_trigger->tgnargs;
         /* tgattr is first var-width field, so OK to access directly */
         build->tgnattr = pg_trigger->tgattr.dim1;
         if (build->tgnattr > 0)
         {
             build->tgattr = (int16 *) palloc(build->tgnattr * sizeof(int16));
             memcpy(build->tgattr, &(pg_trigger->tgattr.values),
                    build->tgnattr * sizeof(int16));
         }
         else
             build->tgattr = NULL;
         if (build->tgnargs > 0)
         {
             bytea      *val;
             char       *p;
  
             val = DatumGetByteaPP(fastgetattr(htup,
                                               Anum_pg_trigger_tgargs,
                                               tgrel->rd_att, &isnull));
             if (isnull)
                 elog(ERROR, "tgargs is null in trigger for relation \"%s\"",
                      RelationGetRelationName(relation));
             p = (char *) VARDATA_ANY(val);
             build->tgargs = (char **) palloc(build->tgnargs * sizeof(char *));
             for (i = 0; i < build->tgnargs; i++)
             {
                 build->tgargs[i] = pstrdup(p);
                 p += strlen(p) + 1;
             }
         }
         else
             build->tgargs = NULL;
  
         datum = fastgetattr(htup, Anum_pg_trigger_tgoldtable,
                             tgrel->rd_att, &isnull);
         if (!isnull)
             build->tgoldtable =
                 DatumGetCString(DirectFunctionCall1(nameout, datum));
         else
             build->tgoldtable = NULL;
  
         datum = fastgetattr(htup, Anum_pg_trigger_tgnewtable,
                             tgrel->rd_att, &isnull);
         if (!isnull)
             build->tgnewtable =
                 DatumGetCString(DirectFunctionCall1(nameout, datum));
         else
             build->tgnewtable = NULL;
  
         datum = fastgetattr(htup, Anum_pg_trigger_tgqual,
                             tgrel->rd_att, &isnull);
         if (!isnull)
             build->tgqual = TextDatumGetCString(datum);
         else
             build->tgqual = NULL;
  
         numtrigs++;
     }
  
     systable_endscan(tgscan);
     table_close(tgrel, AccessShareLock);
  
     /* There might not be any triggers */
     if (numtrigs == 0)
     {
         pfree(triggers);
         return;
     }
  
     /* Build trigdesc */
     trigdesc = (TriggerDesc *) palloc0(sizeof(TriggerDesc));
     trigdesc->triggers = triggers;
     trigdesc->numtriggers = numtrigs;
     for (i = 0; i < numtrigs; i++)
         SetTriggerFlags(trigdesc, &(triggers[i]));
  
     /* Copy completed trigdesc into cache storage */
     oldContext = MemoryContextSwitchTo(CacheMemoryContext);
     relation->trigdesc = CopyTriggerDesc(trigdesc);
     MemoryContextSwitchTo(oldContext);
  
     /* Release working memory */
     FreeTriggerDesc(trigdesc);
 }

References AccessShareLock, BTEqualStrategyNumber, CacheMemoryContext, CopyTriggerDesc(), DatumGetByteaPP, DatumGetCString(), DirectFunctionCall1, elog(), ERROR, fastgetattr(), FreeTriggerDesc(), GETSTRUCT, HeapTupleIsValid, i, MemoryContextSwitchTo(), NameGetDatum(), nameout(), TriggerDesc::numtriggers, ObjectIdGetDatum(), OidIsValid, palloc(), palloc0(), pfree(), pstrdup(), RelationData::rd_att, RelationGetRelationName, RelationGetRelid, repalloc(), ScanKeyInit(), SetTriggerFlags(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, Trigger::tgargs, Trigger::tgattr, Trigger::tgconstraint, Trigger::tgconstrindid, Trigger::tgconstrrelid, Trigger::tgdeferrable, Trigger::tgenabled, Trigger::tgfoid, Trigger::tginitdeferred, Trigger::tgisclone, Trigger::tgisinternal, Trigger::tgname, Trigger::tgnargs, Trigger::tgnattr, Trigger::tgnewtable, Trigger::tgoid, Trigger::tgoldtable, Trigger::tgqual, Trigger::tgtype, RelationData::trigdesc, TriggerDesc::triggers, val, and VARDATA_ANY.

Referenced by RelationBuildDesc(), and RelationCacheInitializePhase3().

◆ RemoveTriggerById()

void RemoveTriggerById ( Oid trigOid )

Definition at line 1298 of file trigger.c.

 {
     Relation    tgrel;
     SysScanDesc tgscan;
     ScanKeyData skey[1];
     HeapTuple   tup;
     Oid         relid;
     Relation    rel;
  
     tgrel = table_open(TriggerRelationId, RowExclusiveLock);
  
     /*
      * Find the trigger to delete.
      */
     ScanKeyInit(&skey[0],
                 Anum_pg_trigger_oid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(trigOid));
  
     tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,
                                 NULL, 1, skey);
  
     tup = systable_getnext(tgscan);
     if (!HeapTupleIsValid(tup))
         elog(ERROR, "could not find tuple for trigger %u", trigOid);
  
     /*
      * Open and exclusive-lock the relation the trigger belongs to.
      */
     relid = ((Form_pg_trigger) GETSTRUCT(tup))->tgrelid;
  
     rel = table_open(relid, AccessExclusiveLock);
  
     if (rel->rd_rel->relkind != RELKIND_RELATION &&
         rel->rd_rel->relkind != RELKIND_VIEW &&
         rel->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
         rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("relation \"%s\" cannot have triggers",
                         RelationGetRelationName(rel)),
                  errdetail_relkind_not_supported(rel->rd_rel->relkind)));
  
     if (!allowSystemTableMods && IsSystemRelation(rel))
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("permission denied: \"%s\" is a system catalog",
                         RelationGetRelationName(rel))));
  
     /*
      * Delete the pg_trigger tuple.
      */
     CatalogTupleDelete(tgrel, &tup->t_self);
  
     systable_endscan(tgscan);
     table_close(tgrel, RowExclusiveLock);
  
     /*
      * 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.
      */
     CacheInvalidateRelcache(rel);
  
     /* Keep lock on trigger's rel until end of xact */
     table_close(rel, NoLock);
 }

References AccessExclusiveLock, allowSystemTableMods, BTEqualStrategyNumber, CacheInvalidateRelcache(), CatalogTupleDelete(), elog(), ereport, errcode(), errdetail_relkind_not_supported(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, IsSystemRelation(), NoLock, ObjectIdGetDatum(), RelationData::rd_rel, RelationGetRelationName, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

◆ renametrig()

ObjectAddress renametrig ( RenameStmt * stmt )

Definition at line 1474 of file trigger.c.

 {
     Oid         tgoid;
     Relation    targetrel;
     Relation    tgrel;
     HeapTuple   tuple;
     SysScanDesc tgscan;
     ScanKeyData key[2];
     Oid         relid;
     ObjectAddress address;
  
     /*
      * Look up name, check permissions, and acquire lock (which we will NOT
      * release until end of transaction).
      */
     relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
                                      0,
                                      RangeVarCallbackForRenameTrigger,
                                      NULL);
  
     /* Have lock already, so just need to build relcache entry. */
     targetrel = relation_open(relid, NoLock);
  
     /*
      * 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);
  
     tgrel = table_open(TriggerRelationId, RowExclusiveLock);
  
     /*
      * Search for the trigger to modify.
      */
     ScanKeyInit(&key[0],
                 Anum_pg_trigger_tgrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(relid));
     ScanKeyInit(&key[1],
                 Anum_pg_trigger_tgname,
                 BTEqualStrategyNumber, F_NAMEEQ,
                 PointerGetDatum(stmt->subname));
     tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
                                 NULL, 2, key);
     if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
     {
         Form_pg_trigger trigform;
  
         trigform = (Form_pg_trigger) GETSTRUCT(tuple);
         tgoid = trigform->oid;
  
         /*
          * 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))
             ereport(ERROR,
                     errmsg("cannot rename trigger \"%s\" on table \"%s\"",
                            stmt->subname, RelationGetRelationName(targetrel)),
                     errhint("Rename the trigger on the partitioned table \"%s\" instead.",
                             get_rel_name(get_partition_parent(relid, false))));
  
  
         /* Rename the trigger on this relation ... */
         renametrig_internal(tgrel, targetrel, tuple, stmt->newname,
                             stmt->subname);
  
         /* ... and if it is partitioned, recurse to its partitions */
         if (targetrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
         {
             PartitionDesc partdesc = RelationGetPartitionDesc(targetrel, true);
  
             for (int i = 0; i < partdesc->nparts; i++)
             {
                 Oid         partitionId = partdesc->oids[i];
  
                 renametrig_partition(tgrel, partitionId, trigform->oid,
                                      stmt->newname, stmt->subname);
             }
         }
     }
     else
     {
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("trigger \"%s\" for table \"%s\" does not exist",
                         stmt->subname, RelationGetRelationName(targetrel))));
     }
  
     ObjectAddressSet(address, TriggerRelationId, tgoid);
  
     systable_endscan(tgscan);
  
     table_close(tgrel, RowExclusiveLock);
  
     /*
      * Close rel, but keep exclusive lock!
      */
     relation_close(targetrel, NoLock);
  
     return address;
 }

References AccessExclusiveLock, BTEqualStrategyNumber, ereport, errcode(), errhint(), errmsg(), ERROR, find_all_inheritors(), get_partition_parent(), get_rel_name(), GETSTRUCT, HeapTupleIsValid, i, sort-test::key, NoLock, PartitionDescData::nparts, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, PartitionDescData::oids, PointerGetDatum(), RangeVarCallbackForRenameTrigger(), RangeVarGetRelidExtended(), RelationData::rd_rel, relation_close(), relation_open(), RelationGetPartitionDesc(), RelationGetRelationName, renametrig_internal(), renametrig_partition(), RowExclusiveLock, ScanKeyInit(), stmt, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ExecRenameStmt().

◆ RI_FKey_fk_upd_check_required()

bool RI_FKey_fk_upd_check_required	(	Trigger *	trigger,
		Relation	fk_rel,
		TupleTableSlot *	oldslot,
		TupleTableSlot *	newslot
	)

Definition at line 1261 of file ri_triggers.c.

 {
     const RI_ConstraintInfo *riinfo;
     int         ri_nullcheck;
     Datum       xminDatum;
     TransactionId xmin;
     bool        isnull;
  
     /*
      * AfterTriggerSaveEvent() handles things such that this function is never
      * called for partitioned tables.
      */
     Assert(fk_rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE);
  
     riinfo = ri_FetchConstraintInfo(trigger, fk_rel, false);
  
     ri_nullcheck = ri_NullCheck(RelationGetDescr(fk_rel), newslot, riinfo, false);
  
     /*
      * If all new key values are NULL, the row satisfies the constraint, so no
      * check is needed.
      */
     if (ri_nullcheck == RI_KEYS_ALL_NULL)
         return false;
  
     /*
      * If some new key values are NULL, the behavior depends on the match
      * type.
      */
     else if (ri_nullcheck == RI_KEYS_SOME_NULL)
     {
         switch (riinfo->confmatchtype)
         {
             case FKCONSTR_MATCH_SIMPLE:
  
                 /*
                  * If any new key value is NULL, the row must satisfy the
                  * constraint, so no check is needed.
                  */
                 return false;
  
             case FKCONSTR_MATCH_PARTIAL:
  
                 /*
                  * Don't know, must run full check.
                  */
                 break;
  
             case FKCONSTR_MATCH_FULL:
  
                 /*
                  * If some new key values are NULL, the row fails the
                  * constraint.  We must not throw error here, because the row
                  * might get invalidated before the constraint is to be
                  * checked, but we should queue the event to apply the check
                  * later.
                  */
                 return true;
         }
     }
  
     /*
      * Continues here for no new key values are NULL, or we couldn't decide
      * yet.
      */
  
     /*
      * If the original row was inserted by our own transaction, we must fire
      * the trigger whether or not the keys are equal.  This is because our
      * UPDATE will invalidate the INSERT so that the INSERT RI trigger will
      * not do anything; so we had better do the UPDATE check.  (We could skip
      * this if we knew the INSERT trigger already fired, but there is no easy
      * way to know that.)
      */
     xminDatum = slot_getsysattr(oldslot, MinTransactionIdAttributeNumber, &isnull);
     Assert(!isnull);
     xmin = DatumGetTransactionId(xminDatum);
     if (TransactionIdIsCurrentTransactionId(xmin))
         return true;
  
     /* If all old and new key values are equal, no check is needed */
     if (ri_KeysEqual(fk_rel, oldslot, newslot, riinfo, false))
         return false;
  
     /* Else we need to fire the trigger. */
     return true;
 }

References Assert(), RI_ConstraintInfo::confmatchtype, DatumGetTransactionId(), FKCONSTR_MATCH_FULL, FKCONSTR_MATCH_PARTIAL, FKCONSTR_MATCH_SIMPLE, MinTransactionIdAttributeNumber, RelationData::rd_rel, RelationGetDescr, ri_FetchConstraintInfo(), RI_KEYS_ALL_NULL, RI_KEYS_SOME_NULL, ri_KeysEqual(), ri_NullCheck(), slot_getsysattr(), and TransactionIdIsCurrentTransactionId().

Referenced by AfterTriggerSaveEvent().

◆ RI_FKey_pk_upd_check_required()

bool RI_FKey_pk_upd_check_required	(	Trigger *	trigger,
		Relation	pk_rel,
		TupleTableSlot *	oldslot,
		TupleTableSlot *	newslot
	)

Definition at line 1229 of file ri_triggers.c.

 {
     const RI_ConstraintInfo *riinfo;
  
     riinfo = ri_FetchConstraintInfo(trigger, pk_rel, true);
  
     /*
      * If any old key value is NULL, the row could not have been referenced by
      * an FK row, so no check is needed.
      */
     if (ri_NullCheck(RelationGetDescr(pk_rel), oldslot, riinfo, true) != RI_KEYS_NONE_NULL)
         return false;
  
     /* If all old and new key values are equal, no check is needed */
     if (newslot && ri_KeysEqual(pk_rel, oldslot, newslot, riinfo, true))
         return false;
  
     /* Else we need to fire the trigger. */
     return true;
 }

References RelationGetDescr, ri_FetchConstraintInfo(), RI_KEYS_NONE_NULL, ri_KeysEqual(), and ri_NullCheck().