#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:

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)

void	RemoveTriggerById (Oid trigOid)

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

ObjectAddress	renametrig (RenameStmt *stmt)

void	EnableDisableTrigger (Relation rel, const char *tgname, char fires_when, bool skip_system, 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)

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

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 slot)

void	ExecARUpdateTriggers (EState estate, ResultRelInfo relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot slot, List recheckIndexes, TransitionCaptureState *transition_capture)

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

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 old_slot, TupleTableSlot *new_slot)

bool	RI_FKey_fk_upd_check_required (Trigger trigger, Relation fk_rel, TupleTableSlot old_slot, TupleTableSlot *new_slot)

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 114 of file trigger.h.

Referenced by afterTriggerCheckState(), AfterTriggerSaveEvent(), and ExecCallTriggerFunc().

◆ AFTER_TRIGGER_INITDEFERRED

#define AFTER_TRIGGER_INITDEFERRED 0x00000040

Definition at line 115 of file trigger.h.

Referenced by afterTriggerCheckState(), AfterTriggerSaveEvent(), and ExecCallTriggerFunc().

◆ CALLED_AS_TRIGGER

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

◆ RI_TRIGGER_FK

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

Definition at line 272 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), and RI_FKey_trigger_type().

◆ RI_TRIGGER_NONE

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

Definition at line 273 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), and RI_FKey_trigger_type().

◆ RI_TRIGGER_PK

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

Definition at line 271 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), and RI_FKey_trigger_type().

◆ SESSION_REPLICATION_ROLE_LOCAL

#define SESSION_REPLICATION_ROLE_LOCAL 2

Definition at line 149 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_ORIGIN

#define SESSION_REPLICATION_ROLE_ORIGIN 0

Definition at line 147 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_REPLICA

#define SESSION_REPLICATION_ROLE_REPLICA 1

Definition at line 148 of file trigger.h.

Referenced by filter_event_trigger(), matchLocks(), and TriggerEnabled().

◆ TRIGGER_DISABLED

#define TRIGGER_DISABLED 'D'

Definition at line 159 of file trigger.h.

Referenced by ATExecCmd(), BuildEventTriggerCache(), and TriggerEnabled().

◆ TRIGGER_EVENT_AFTER

#define TRIGGER_EVENT_AFTER 0x00000000

Definition at line 108 of file trigger.h.

◆ TRIGGER_EVENT_BEFORE

#define TRIGGER_EVENT_BEFORE 0x00000008

Definition at line 107 of file trigger.h.

Referenced by ExecBRDeleteTriggers(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecBSDeleteTriggers(), ExecBSInsertTriggers(), ExecBSTruncateTriggers(), and ExecBSUpdateTriggers().

◆ TRIGGER_EVENT_DELETE

#define TRIGGER_EVENT_DELETE 0x00000001

Definition at line 100 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), ExecARDeleteTriggers(), ExecASDeleteTriggers(), ExecBRDeleteTriggers(), ExecBSDeleteTriggers(), and ExecIRDeleteTriggers().

◆ TRIGGER_EVENT_INSERT

#define TRIGGER_EVENT_INSERT 0x00000000

Definition at line 99 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), ExecARInsertTriggers(), ExecASInsertTriggers(), ExecBRInsertTriggers(), ExecBSInsertTriggers(), ExecIRInsertTriggers(), and validateForeignKeyConstraint().

◆ TRIGGER_EVENT_INSTEAD

#define TRIGGER_EVENT_INSTEAD 0x00000010

Definition at line 109 of file trigger.h.

Referenced by ExecIRDeleteTriggers(), ExecIRInsertTriggers(), and ExecIRUpdateTriggers().

◆ TRIGGER_EVENT_OPMASK

#define TRIGGER_EVENT_OPMASK 0x00000003

Definition at line 103 of file trigger.h.

Referenced by AfterTriggerExecute(), AfterTriggerSaveEvent(), and cancel_prior_stmt_triggers().

◆ TRIGGER_EVENT_ROW

#define TRIGGER_EVENT_ROW 0x00000004

Definition at line 105 of file trigger.h.

Referenced by AfterTriggerExecute(), AfterTriggerSaveEvent(), ExecBRDeleteTriggers(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecIRDeleteTriggers(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), and validateForeignKeyConstraint().

◆ TRIGGER_EVENT_TIMINGMASK

#define TRIGGER_EVENT_TIMINGMASK 0x00000018

Definition at line 110 of file trigger.h.

◆ TRIGGER_EVENT_TRUNCATE

#define TRIGGER_EVENT_TRUNCATE 0x00000003

Definition at line 102 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), ExecASTruncateTriggers(), and ExecBSTruncateTriggers().

◆ TRIGGER_EVENT_UPDATE

#define TRIGGER_EVENT_UPDATE 0x00000002

Definition at line 101 of file trigger.h.

Referenced by AfterTriggerExecute(), AfterTriggerSaveEvent(), ExecARUpdateTriggers(), ExecASUpdateTriggers(), ExecBRUpdateTriggers(), ExecBSUpdateTriggers(), and ExecIRUpdateTriggers().

◆ TRIGGER_FIRED_AFTER

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

Definition at line 138 of file trigger.h.

Referenced by cancel_prior_stmt_triggers(), ExecCallTriggerFunc(), plperl_trigger_build_args(), plpgsql_fulfill_promise(), pltcl_trigger_handler(), PLy_trigger_build_args(), ri_CheckTrigger(), triggered_change_notification(), and unique_key_recheck().

◆ TRIGGER_FIRED_BEFORE

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

Definition at line 135 of file trigger.h.

Referenced by autoinc(), insert_username(), moddatetime(), plperl_trigger_build_args(), plpgsql_exec_trigger(), plpgsql_fulfill_promise(), pltcl_trigger_handler(), PLy_trigger_build_args(), suppress_redundant_updates_trigger(), tsvector_update_trigger(), and ttdummy().

◆ TRIGGER_FIRED_BY_DELETE

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

Definition at line 120 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), check_primary_key(), ExecCallTriggerFunc(), lo_manage(), plperl_trigger_build_args(), plperl_trigger_handler(), plpgsql_exec_trigger(), plpgsql_fulfill_promise(), pltcl_trigger_handler(), PLy_trigger_build_args(), ri_CheckTrigger(), and triggered_change_notification().

◆ TRIGGER_FIRED_BY_INSERT

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

◆ TRIGGER_FIRED_BY_TRUNCATE

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

Definition at line 126 of file trigger.h.

Referenced by plperl_trigger_build_args(), plperl_trigger_handler(), plpgsql_fulfill_promise(), pltcl_trigger_handler(), and PLy_trigger_build_args().

◆ TRIGGER_FIRED_BY_UPDATE

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

◆ TRIGGER_FIRED_FOR_ROW

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

Definition at line 129 of file trigger.h.

Referenced by autoinc(), check_foreign_key(), check_primary_key(), insert_username(), lo_manage(), moddatetime(), plperl_trigger_build_args(), plpgsql_exec_trigger(), plpgsql_fulfill_promise(), pltcl_trigger_handler(), PLy_trigger_build_args(), ri_CheckTrigger(), suppress_redundant_updates_trigger(), triggered_change_notification(), tsvector_update_trigger(), ttdummy(), and unique_key_recheck().

◆ TRIGGER_FIRED_FOR_STATEMENT

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

Definition at line 132 of file trigger.h.

Referenced by cancel_prior_stmt_triggers(), plperl_trigger_build_args(), plpgsql_fulfill_promise(), pltcl_trigger_handler(), and PLy_trigger_build_args().

◆ TRIGGER_FIRED_INSTEAD

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

Definition at line 141 of file trigger.h.

Referenced by plperl_trigger_build_args(), plpgsql_fulfill_promise(), pltcl_trigger_handler(), and PLy_trigger_build_args().

◆ TRIGGER_FIRES_ALWAYS

#define TRIGGER_FIRES_ALWAYS 'A'

Definition at line 157 of file trigger.h.

Referenced by ATExecCmd().

◆ TRIGGER_FIRES_ON_ORIGIN

#define TRIGGER_FIRES_ON_ORIGIN 'O'

Definition at line 156 of file trigger.h.

Referenced by ATDetachCheckNoForeignKeyRefs(), ATExecCmd(), CreateTrigger(), filter_event_trigger(), insert_event_trigger_tuple(), TriggerEnabled(), and validateForeignKeyConstraint().

◆ TRIGGER_FIRES_ON_REPLICA

#define TRIGGER_FIRES_ON_REPLICA 'R'

Definition at line 158 of file trigger.h.

Referenced by ATExecCmd(), filter_event_trigger(), and TriggerEnabled().

Typedef Documentation

◆ TransitionCaptureState

typedef struct TransitionCaptureState TransitionCaptureState

◆ TriggerData

typedef struct TriggerData TriggerData

◆ TriggerEvent

typedef uint32 TriggerEvent

Definition at line 28 of file trigger.h.

Function Documentation

◆ AfterTriggerBeginQuery()

void AfterTriggerBeginQuery ( void )

Definition at line 4432 of file trigger.c.

References AfterTriggersData::query_depth.

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

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

◆ AfterTriggerBeginSubXact()

void AfterTriggerBeginSubXact ( void )

Definition at line 4700 of file trigger.c.

References 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().

 {
     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;
 }

◆ AfterTriggerBeginXact()

void AfterTriggerBeginXact ( void )

Definition at line 4400 of file trigger.c.

References 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().

 {
     /*
      * 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);
 }

◆ AfterTriggerEndQuery()

void AfterTriggerEndQuery ( EState * estate )

Definition at line 4452 of file trigger.c.

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

Referenced by apply_handle_delete(), apply_handle_insert(), apply_handle_update(), CopyFrom(), ExecuteTruncateGuts(), and standard_ExecutorFinish().

 {
     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--;
 }

◆ AfterTriggerEndSubXact()

void AfterTriggerEndSubXact ( bool isCommit )

Definition at line 4748 of file trigger.c.

References AFTER_TRIGGER_DONE, AFTER_TRIGGER_IN_PROGRESS, AfterTriggerFreeQuery(), afterTriggerRestoreEventList(), 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().

 {
     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);
             }
         }
     }
 }

◆ AfterTriggerEndXact()

void AfterTriggerEndXact ( bool isCommit )

Definition at line 4652 of file trigger.c.

References 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().

 {
     /*
      * 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;
 }

◆ AfterTriggerFireDeferred()

void AfterTriggerFireDeferred ( void )

Definition at line 4596 of file trigger.c.

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

Referenced by CommitTransaction(), and PrepareTransaction().

 {
     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();
 }

◆ AfterTriggerPendingOnRel()

bool AfterTriggerPendingOnRel ( Oid relid )

Definition at line 5287 of file trigger.c.

References AFTER_TRIGGER_DONE, 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().

 {
     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;
 }

◆ AfterTriggerSetState()

void AfterTriggerSetState ( ConstraintsSetStmt * stmt )

Definition at line 4972 of file trigger.c.

References AccessShareLock, afterTriggerInvokeEvents(), afterTriggerMarkEvents(), SetConstraintStateData::all_isdeferred, SetConstraintStateData::all_isset, BTEqualStrategyNumber, RangeVar::catalogname, ConstraintNameNspIndexId, ConstraintParentIndexId, ConstraintsSetStmt::constraints, CStringGetDatum, ConstraintsSetStmt::deferred, 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, SetConstraintTriggerData::sct_tgisdeferred, SetConstraintTriggerData::sct_tgoid, SetConstraintStateAddItem(), SetConstraintStateCopy(), SetConstraintStateCreate(), AfterTriggersData::state, AfterTriggersTransData::state, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), AfterTriggersData::trans_stack, TriggerConstraintIndexId, and SetConstraintStateData::trigstates.

Referenced by standard_ProcessUtility().

 {
     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();
     }
 }

◆ CopyTriggerDesc()

TriggerDesc* CopyTriggerDesc ( TriggerDesc * trigdesc )

Definition at line 1821 of file trigger.c.

References i, 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().

 {
     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;
 }

◆ 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 157 of file trigger.c.

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

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

 {
     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;
     SysScanDesc tgscan;
     ScanKeyData key;
     Relation    pgrel;
     HeapTuple   tuple;
     Oid         funcrettype;
     Oid         trigoid;
     char        internaltrigname[NAMEDATALEN];
     char       *trigname;
     Oid         constrrelid = InvalidOid;
     ObjectAddress myself,
                 referenced;
     char       *oldtablename = NULL;
     char       *newtablename = NULL;
     bool        partition_recurse;
 
     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("Triggers on partitioned tables cannot have transition 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.")));
 
         if (TRIGGER_FOR_TRUNCATE(stmt->events))
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("\"%s\" is a foreign table",
                             RelationGetRelationName(rel)),
                      errdetail("Foreign tables cannot have TRUNCATE 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("\"%s\" is not a table or view",
                         RelationGetRelationName(rel))));
 
     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 = pg_proc_aclcheck(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")));
 
     /*
      * 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, /* no exclusion */
                                               NULL, /* no check constraint */
                                               NULL,
                                               true, /* islocal */
                                               0,    /* inhcount */
                                               true, /* noinherit */
                                               isInternal);  /* is_internal */
     }
 
     /*
      * Generate the trigger's OID now, so that we can use it in the name if
      * needed.
      */
     tgrel = table_open(TriggerRelationId, RowExclusiveLock);
 
     trigoid = GetNewOidWithIndex(tgrel, TriggerOidIndexId,
                                  Anum_pg_trigger_oid);
 
     /*
      * 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;
     }
 
     /*
      * Scan pg_trigger for existing triggers on relation.  We do this only to
      * give a nice error message if there's already a trigger of the same
      * name.  (The unique index on tgrelid/tgname would complain anyway.) We
      * can skip this for internally generated triggers, since the name
      * modification above should be sufficient.
      *
      * NOTE that this is cool only because we have ShareRowExclusiveLock on
      * the relation, so the trigger set won't be changing underneath us.
      */
     if (!isInternal)
     {
         ScanKeyInit(&key,
                     Anum_pg_trigger_tgrelid,
                     BTEqualStrategyNumber, F_OIDEQ,
                     ObjectIdGetDatum(RelationGetRelid(rel)));
         tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
                                     NULL, 1, &key);
         while (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
         {
             Form_pg_trigger pg_trigger = (Form_pg_trigger) GETSTRUCT(tuple);
 
             if (namestrcmp(&(pg_trigger->tgname), trigname) == 0)
                 ereport(ERROR,
                         (errcode(ERRCODE_DUPLICATE_OBJECT),
                          errmsg("trigger \"%s\" for relation \"%s\" already exists",
                                 trigname, RelationGetRelationName(rel))));
         }
         systable_endscan(tgscan);
     }
 
     /*
      * 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] = CharGetDatum(TRIGGER_FIRES_ON_ORIGIN);
     values[Anum_pg_trigger_tgisinternal - 1] = BoolGetDatum(isInternal || in_partition);
     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;
 
     tuple = heap_form_tuple(tgrel->rd_att, values, nulls);
 
     /*
      * Insert tuple into pg_trigger.
      */
     CatalogTupleInsert(tgrel, tuple);
 
     heap_freetuple(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);
 
     /*
      * 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);
         List       *idxs = NIL;
         List       *childTbls = NIL;
         ListCell   *l;
         int         i;
         MemoryContext oldcxt,
                     perChildCxt;
 
         perChildCxt = AllocSetContextCreate(CurrentMemoryContext,
                                             "part trig clone",
                                             ALLOCSET_SMALL_SIZES);
 
         /*
          * When a trigger is being created associated with an index, we'll
          * need to associate the trigger in each child partition with the
          * corresponding index on it.
          */
         if (OidIsValid(indexOid))
         {
             ListCell   *l;
             List       *idxs = NIL;
 
             idxs = find_inheritance_children(indexOid, ShareRowExclusiveLock);
             foreach(l, idxs)
                 childTbls = lappend_oid(childTbls,
                                         IndexGetRelation(lfirst_oid(l),
                                                          false));
         }
 
         oldcxt = MemoryContextSwitchTo(perChildCxt);
 
         /* Iterate to create the trigger on each existing partition */
         for (i = 0; i < partdesc->nparts; i++)
         {
             Oid         indexOnChild = InvalidOid;
             ListCell   *l2;
             CreateTrigStmt *childStmt;
             Relation    childTbl;
             Node       *qual;
 
             childTbl = table_open(partdesc->oids[i], ShareRowExclusiveLock);
 
             /* Find which of the child indexes is the one on this partition */
             if (OidIsValid(indexOid))
             {
                 forboth(l, idxs, l2, childTbls)
                 {
                     if (lfirst_oid(l2) == partdesc->oids[i])
                     {
                         indexOnChild = lfirst_oid(l);
                         break;
                     }
                 }
                 if (!OidIsValid(indexOnChild))
                     elog(ERROR, "failed to find index matching index \"%s\" in partition \"%s\"",
                          get_rel_name(indexOid),
                          get_rel_name(partdesc->oids[i]));
             }
 
             /*
              * 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);
 
             CreateTrigger(childStmt, queryString,
                           partdesc->oids[i], refRelOid,
                           InvalidOid, indexOnChild,
                           funcoid, trigoid, qual,
                           isInternal, true);
 
             table_close(childTbl, NoLock);
 
             MemoryContextReset(perChildCxt);
         }
 
         MemoryContextSwitchTo(oldcxt);
         MemoryContextDelete(perChildCxt);
         list_free(idxs);
         list_free(childTbls);
     }
 
     /* Keep lock on target rel until end of xact */
     table_close(rel, NoLock);
 
     return myself;
 }

◆ EnableDisableTrigger()

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

Definition at line 1469 of file trigger.c.

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

Referenced by ATExecEnableDisableTrigger(), and EnableDisableTrigger().

 {
     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 (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);
 
             /*
              * When altering FOR EACH ROW triggers on a partitioned table, do
              * the same on the partitions as well.
              */
             if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
                 (TRIGGER_FOR_ROW(oldtrig->tgtype)))
             {
                 PartitionDesc partdesc = RelationGetPartitionDesc(rel);
                 int         i;
 
                 for (i = 0; i < partdesc->nparts; i++)
                 {
                     Relation    part;
 
                     part = relation_open(partdesc->oids[i], lockmode);
                     EnableDisableTrigger(part, NameStr(oldtrig->tgname),
                                          fires_when, skip_system, lockmode);
                     table_close(part, NoLock);  /* keep lock till commit */
                 }
             }
 
             changed = true;
         }
 
         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);
 }

◆ ExecARDeleteTriggers()

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

Definition at line 2498 of file trigger.c.

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 ExecDelete(), and ExecSimpleRelationDelete().

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

◆ ExecARInsertTriggers()

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

Definition at line 2268 of file trigger.c.

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

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

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

◆ ExecARUpdateTriggers()

void ExecARUpdateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		ItemPointer	tupleid,
		HeapTuple	fdw_trigtuple,
		TupleTableSlot *	slot,
		List *	recheckIndexes,
		TransitionCaptureState *	transition_capture
	)

Definition at line 2783 of file trigger.c.

References AfterTriggerSaveEvent(), ExecClearTuple(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), GetAllUpdatedColumns, 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 ExecDelete(), ExecInsert(), ExecSimpleRelationUpdate(), and ExecUpdate().

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     TupleTableSlot *oldslot = ExecGetTriggerOldSlot(estate, relinfo);
 
     ExecClearTuple(oldslot);
 
     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.
          */
         if (fdw_trigtuple == NULL && ItemPointerIsValid(tupleid))
             GetTupleForTrigger(estate,
                                NULL,
                                relinfo,
                                tupleid,
                                LockTupleExclusive,
                                oldslot,
                                NULL);
         else if (fdw_trigtuple != NULL)
             ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, false);
 
         AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_UPDATE,
                               true, oldslot, newslot, recheckIndexes,
                               GetAllUpdatedColumns(relinfo, estate),
                               transition_capture);
     }
 }

◆ ExecASDeleteTriggers()

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

Definition at line 2395 of file trigger.c.

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

Referenced by fireASTriggers().

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

◆ ExecASInsertTriggers()

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

Definition at line 2181 of file trigger.c.

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

Referenced by CopyFrom(), and fireASTriggers().

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

◆ ExecASTruncateTriggers()

void ExecASTruncateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2938 of file trigger.c.

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

Referenced by ExecuteTruncateGuts().

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

◆ ExecASUpdateTriggers()

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

Definition at line 2630 of file trigger.c.

References AfterTriggerSaveEvent(), GetAllUpdatedColumns, NIL, ResultRelInfo::ri_TrigDesc, TriggerDesc::trig_update_after_statement, and TRIGGER_EVENT_UPDATE.

Referenced by fireASTriggers().

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

◆ ExecBRDeleteTriggers()

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

Definition at line 2413 of file trigger.c.

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, T_TriggerData, 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 ExecDelete(), and ExecSimpleRelationDelete().

 {
     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))
             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;
 }

◆ ExecBRInsertTriggers()

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

Definition at line 2192 of file trigger.c.

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, T_TriggerData, 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().

 {
     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;
 }

◆ ExecBRUpdateTriggers()

bool ExecBRUpdateTriggers	(	EState *	estate,
		EPQState *	epqstate,
		ResultRelInfo *	relinfo,
		ItemPointer	tupleid,
		HeapTuple	fdw_trigtuple,
		TupleTableSlot *	slot
	)

Definition at line 2643 of file trigger.c.

References Assert, ereport, errcode(), errdetail(), errmsg(), ERROR, ExecCallTriggerFunc(), ExecCopySlot(), ExecFetchSlotHeapTuple(), ExecFilterJunk(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), ExecMaterializeSlot(), ExecPartitionCheck(), ExecUpdateLockMode(), get_namespace_name(), GetAllUpdatedColumns, GetPerTupleMemoryContext, GetTupleForTrigger(), heap_freetuple(), HeapTupleIsValid, i, ItemPointerIsValid, TriggerDesc::numtriggers, RelationGetNamespace, RelationGetRelationName, ResultRelInfo::ri_junkFilter, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, 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::tgisclone, Trigger::tgname, Trigger::tgtype, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_ROW, TRIGGER_EVENT_UPDATE, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by ExecSimpleRelationUpdate(), and ExecUpdate().

 {
     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))
             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 run it
          * through the junk filter to produce an insertable tuple.
          *
          * Caution: more than likely, the passed-in slot is the same as the
          * junkfilter's output slot, so we are clobbering the original value
          * of slottuple by doing the filtering.  This is OK since neither we
          * nor our caller have any more interest in the prior contents of that
          * slot.
          */
         if (epqslot_candidate != NULL)
         {
             TupleTableSlot *epqslot_clean;
 
             epqslot_clean = ExecFilterJunk(relinfo->ri_junkFilter, epqslot_candidate);
 
             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 = GetAllUpdatedColumns(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 (trigger->tgisclone &&
                 !ExecPartitionCheck(relinfo, newslot, estate, false))
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("moving row to another partition during a BEFORE 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 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;
 }

◆ ExecBSDeleteTriggers()

void ExecBSDeleteTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2344 of file trigger.c.

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, T_TriggerData, 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().

 {
     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")));
     }
 }

◆ ExecBSInsertTriggers()

void ExecBSInsertTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2130 of file trigger.c.

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, T_TriggerData, 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().

 {
     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")));
     }
 }

◆ ExecBSTruncateTriggers()

void ExecBSTruncateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2891 of file trigger.c.

References ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, 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().

 {
     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")));
     }
 }

◆ ExecBSUpdateTriggers()

void ExecBSUpdateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2575 of file trigger.c.

References before_stmt_triggers_fired(), CMD_UPDATE, ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), GetAllUpdatedColumns, GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, RelationGetRelid, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, 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().

 {
     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;
 
     updatedCols = GetAllUpdatedColumns(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")));
     }
 }

◆ ExecIRDeleteTriggers()

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

Definition at line 2528 of file trigger.c.

References ExecCallTriggerFunc(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, 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().

 {
     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;
 }

◆ ExecIRInsertTriggers()

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

Definition at line 2283 of file trigger.c.

References ExecCallTriggerFunc(), ExecFetchSlotHeapTuple(), ExecForceStoreHeapTuple(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, 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().

 {
     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;
 }

◆ ExecIRUpdateTriggers()

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

Definition at line 2825 of file trigger.c.

References ExecCallTriggerFunc(), ExecFetchSlotHeapTuple(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, 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().

 {
     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;
 }

◆ FindTriggerIncompatibleWithInheritance()

const char* FindTriggerIncompatibleWithInheritance ( TriggerDesc * trigdesc )

Definition at line 2008 of file trigger.c.

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

Referenced by ATExecAddInherit(), and ATExecAttachPartition().

 {
     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;
 }

◆ FreeTriggerDesc()

void FreeTriggerDesc ( TriggerDesc * trigdesc )

Definition at line 1876 of file trigger.c.

References i, TriggerDesc::numtriggers, pfree(), 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, and TriggerDesc::triggers.

Referenced by RelationBuildTriggers(), and RelationDestroyRelation().

 {
     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);
 }

◆ get_trigger_oid()

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

Definition at line 1239 of file trigger.c.

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

Referenced by get_object_address_relobject().

 {
     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;
 }

◆ MakeTransitionCaptureState()

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

Definition at line 4310 of file trigger.c.

References AfterTriggerEnlargeQueryState(), CMD_DELETE, CMD_INSERT, CMD_UPDATE, CurrentResourceOwner, CurTransactionContext, CurTransactionResourceOwner, elog, ERROR, GetAfterTriggersTableData(), AfterTriggersData::maxquerydepth, MemoryContextSwitchTo(), AfterTriggersTableData::new_tuplestore, AfterTriggersTableData::old_tuplestore, palloc0(), AfterTriggersData::query_depth, TransitionCaptureState::tcs_delete_old_table, TransitionCaptureState::tcs_insert_new_table, TransitionCaptureState::tcs_private, TransitionCaptureState::tcs_update_new_table, TransitionCaptureState::tcs_update_old_table, 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().

 {
     TransitionCaptureState *state;
     bool        need_old,
                 need_new;
     AfterTriggersTableData *table;
     MemoryContext oldcxt;
     ResourceOwner saveResourceOwner;
 
     if (trigdesc == NULL)
         return NULL;
 
     /* Detect which table(s) we need. */
     switch (cmdType)
     {
         case CMD_INSERT:
             need_old = false;
             need_new = trigdesc->trig_insert_new_table;
             break;
         case CMD_UPDATE:
             need_old = trigdesc->trig_update_old_table;
             need_new = trigdesc->trig_update_new_table;
             break;
         case CMD_DELETE:
             need_old = trigdesc->trig_delete_old_table;
             need_new = false;
             break;
         default:
             elog(ERROR, "unexpected CmdType: %d", (int) cmdType);
             need_old = need_new = false;    /* keep compiler quiet */
             break;
     }
     if (!need_old && !need_new)
         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 && table->old_tuplestore == NULL)
         table->old_tuplestore = tuplestore_begin_heap(false, false, work_mem);
     if (need_new && table->new_tuplestore == NULL)
         table->new_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;
 }

◆ RelationBuildTriggers()

void RelationBuildTriggers ( Relation relation )

Definition at line 1592 of file trigger.c.

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, TriggerRelidNameIndexId, TriggerDesc::triggers, val, and VARDATA_ANY.

Referenced by RelationBuildDesc(), and RelationCacheInitializePhase3().

 {
     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->

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ AFTER_TRIGGER_DEFERRABLE

◆ AFTER_TRIGGER_INITDEFERRED

◆ CALLED_AS_TRIGGER

◆ RI_TRIGGER_FK

◆ RI_TRIGGER_NONE

◆ RI_TRIGGER_PK

◆ SESSION_REPLICATION_ROLE_LOCAL

◆ SESSION_REPLICATION_ROLE_ORIGIN

◆ SESSION_REPLICATION_ROLE_REPLICA

◆ TRIGGER_DISABLED

◆ TRIGGER_EVENT_AFTER

◆ TRIGGER_EVENT_BEFORE

◆ TRIGGER_EVENT_DELETE

◆ TRIGGER_EVENT_INSERT

◆ TRIGGER_EVENT_INSTEAD

◆ TRIGGER_EVENT_OPMASK

◆ TRIGGER_EVENT_ROW

◆ TRIGGER_EVENT_TIMINGMASK

◆ TRIGGER_EVENT_TRUNCATE

◆ TRIGGER_EVENT_UPDATE

◆ TRIGGER_FIRED_AFTER

◆ TRIGGER_FIRED_BEFORE

◆ TRIGGER_FIRED_BY_DELETE

◆ TRIGGER_FIRED_BY_INSERT

◆ TRIGGER_FIRED_BY_TRUNCATE

◆ TRIGGER_FIRED_BY_UPDATE

◆ TRIGGER_FIRED_FOR_ROW

◆ TRIGGER_FIRED_FOR_STATEMENT

◆ TRIGGER_FIRED_INSTEAD

◆ TRIGGER_FIRES_ALWAYS

◆ TRIGGER_FIRES_ON_ORIGIN

◆ TRIGGER_FIRES_ON_REPLICA

Typedef Documentation

◆ TransitionCaptureState

◆ TriggerData

◆ TriggerEvent

Function Documentation

◆ AfterTriggerBeginQuery()

◆ AfterTriggerBeginSubXact()

◆ AfterTriggerBeginXact()

◆ AfterTriggerEndQuery()

◆ AfterTriggerEndSubXact()

◆ AfterTriggerEndXact()

◆ AfterTriggerFireDeferred()

◆ AfterTriggerPendingOnRel()

◆ AfterTriggerSetState()

◆ CopyTriggerDesc()

◆ CreateTrigger()

◆ EnableDisableTrigger()

◆ ExecARDeleteTriggers()

◆ ExecARInsertTriggers()

◆ ExecARUpdateTriggers()

◆ ExecASDeleteTriggers()

◆ ExecASInsertTriggers()

◆ ExecASTruncateTriggers()

◆ ExecASUpdateTriggers()

◆ ExecBRDeleteTriggers()

◆ ExecBRInsertTriggers()

◆ ExecBRUpdateTriggers()

◆ ExecBSDeleteTriggers()

◆ ExecBSInsertTriggers()

◆ ExecBSTruncateTriggers()

◆ ExecBSUpdateTriggers()

◆ ExecIRDeleteTriggers()

◆ ExecIRInsertTriggers()

◆ ExecIRUpdateTriggers()

◆ FindTriggerIncompatibleWithInheritance()

◆ FreeTriggerDesc()

◆ get_trigger_oid()

◆ MakeTransitionCaptureState()

◆ RelationBuildTriggers()