#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, bool isInternal)

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)

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)

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

void	ExecARInsertTriggers (EState estate, ResultRelInfo relinfo, HeapTuple trigtuple, List recheckIndexes, TransitionCaptureState transition_capture)

TupleTableSlot *	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)

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)

TupleTableSlot *	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, HeapTuple newtuple, List recheckIndexes, TransitionCaptureState transition_capture)

TupleTableSlot *	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, HeapTuple old_row, HeapTuple new_row)

bool	RI_FKey_fk_upd_check_required (Trigger *trigger, Relation fk_rel, HeapTuple old_row, HeapTuple new_row)

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

int	RI_FKey_trigger_type (Oid tgfoid)

Variables
PGDLLIMPORT int	SessionReplicationRole

Macro Definition Documentation

#define AFTER_TRIGGER_DEFERRABLE 0x00000020

Definition at line 113 of file trigger.h.

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

#define AFTER_TRIGGER_INITDEFERRED 0x00000040

Definition at line 114 of file trigger.h.

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

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

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

Definition at line 267 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), and RI_FKey_trigger_type().

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

Definition at line 268 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), CreateTrigger(), and RI_FKey_trigger_type().

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

Definition at line 266 of file trigger.h.

Referenced by AfterTriggerSaveEvent(), and RI_FKey_trigger_type().

#define SESSION_REPLICATION_ROLE_LOCAL 2

Definition at line 148 of file trigger.h.

#define SESSION_REPLICATION_ROLE_ORIGIN 0

Definition at line 146 of file trigger.h.

#define SESSION_REPLICATION_ROLE_REPLICA 1

Definition at line 147 of file trigger.h.

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

#define TRIGGER_DISABLED 'D'

Definition at line 158 of file trigger.h.

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

#define TRIGGER_EVENT_AFTER 0x00000000

Definition at line 107 of file trigger.h.

#define TRIGGER_EVENT_BEFORE 0x00000008

Definition at line 106 of file trigger.h.

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

#define TRIGGER_EVENT_DELETE 0x00000001

Definition at line 99 of file trigger.h.

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

#define TRIGGER_EVENT_INSERT 0x00000000

Definition at line 98 of file trigger.h.

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

#define TRIGGER_EVENT_INSTEAD 0x00000010

Definition at line 108 of file trigger.h.

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

#define TRIGGER_EVENT_OPMASK 0x00000003

Definition at line 102 of file trigger.h.

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

#define TRIGGER_EVENT_ROW 0x00000004

Definition at line 104 of file trigger.h.

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

#define TRIGGER_EVENT_TIMINGMASK 0x00000018

Definition at line 109 of file trigger.h.

#define TRIGGER_EVENT_TRUNCATE 0x00000003

Definition at line 101 of file trigger.h.

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

#define TRIGGER_EVENT_UPDATE 0x00000002

Definition at line 100 of file trigger.h.

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

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

Definition at line 137 of file trigger.h.

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

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

Definition at line 134 of file trigger.h.

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

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

Definition at line 119 of file trigger.h.

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

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

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

Definition at line 125 of file trigger.h.

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

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

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

Definition at line 128 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(), pltcl_trigger_handler(), PLy_trigger_build_args(), ri_CheckTrigger(), suppress_redundant_updates_trigger(), timetravel(), triggered_change_notification(), tsvector_update_trigger(), ttdummy(), and unique_key_recheck().

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

Definition at line 131 of file trigger.h.

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

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

Definition at line 140 of file trigger.h.

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

#define TRIGGER_FIRES_ALWAYS 'A'

Definition at line 156 of file trigger.h.

Referenced by ATExecCmd().

#define TRIGGER_FIRES_ON_ORIGIN 'O'

Definition at line 155 of file trigger.h.

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

#define TRIGGER_FIRES_ON_REPLICA 'R'

Definition at line 157 of file trigger.h.

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

Typedef Documentation

typedef struct TransitionCaptureState TransitionCaptureState

typedef struct TriggerData TriggerData

typedef uint32 TriggerEvent

Definition at line 28 of file trigger.h.

Function Documentation

void AfterTriggerBeginQuery ( void )

Definition at line 4540 of file trigger.c.

References AfterTriggersData::query_depth.

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

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

void AfterTriggerBeginSubXact ( void )

Definition at line 4808 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;
 }

void AfterTriggerBeginXact ( void )

Definition at line 4508 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);
 }

void AfterTriggerEndQuery ( EState * estate )

Definition at line 4560 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(), ExecuteTruncate(), 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--;
 }

void AfterTriggerEndSubXact ( bool isCommit )

Definition at line 4856 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);
             }
         }
     }
 }

void AfterTriggerEndXact ( bool isCommit )

Definition at line 4760 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;
 }

void AfterTriggerFireDeferred ( void )

Definition at line 4704 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();
 }

bool AfterTriggerPendingOnRel ( Oid relid )

Definition at line 5374 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;
 }

void AfterTriggerSetState ( ConstraintsSetStmt * stmt )

Definition at line 5080 of file trigger.c.

References AccessShareLock, afterTriggerInvokeEvents(), afterTriggerMarkEvents(), SetConstraintStateData::all_isdeferred, SetConstraintStateData::all_isset, Anum_pg_constraint_conname, Anum_pg_constraint_connamespace, Anum_pg_trigger_tgconstraint, BTEqualStrategyNumber, RangeVar::catalogname, ConstraintNameNspIndexId, ConstraintRelationId, ConstraintsSetStmt::constraints, CStringGetDatum, ConstraintsSetStmt::deferred, elog, ereport, errcode(), errmsg(), ERROR, AfterTriggersData::events, fetch_search_path(), AfterTriggersData::firing_counter, get_database_name(), GetCurrentTransactionNestLevel(), GETSTRUCT, GetTransactionSnapshot(), heap_close, heap_open(), HeapTupleGetOid, HeapTupleIsValid, i, IsSubTransaction(), 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(), AfterTriggersData::trans_stack, TriggerConstraintIndexId, TriggerRelationId, 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.)
          */
         conrel = heap_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,
                                                  HeapTupleGetOid(tup));
                     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)));
         }
 
         heap_close(conrel, AccessShareLock);
 
         /*
          * Now, locate the trigger(s) implementing each of these constraints,
          * and make a list of their OIDs.
          */
         tgrel = heap_open(TriggerRelationId, AccessShareLock);
 
         foreach(lc, conoidlist)
         {
             Oid         conoid = lfirst_oid(lc);
             bool        found;
             ScanKeyData skey;
             SysScanDesc tgscan;
             HeapTuple   htup;
 
             found = false;
 
             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,
                                             HeapTupleGetOid(htup));
 
                 found = true;
             }
 
             systable_endscan(tgscan);
 
             /* Safety check: a deferrable constraint should have triggers */
             if (!found)
                 elog(ERROR, "no triggers found for constraint with OID %u",
                      conoid);
         }
 
         heap_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();
     }
 }

TriggerDesc* CopyTriggerDesc ( TriggerDesc * trigdesc )

Definition at line 1911 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;
 }

ObjectAddress CreateTrigger	(	CreateTrigStmt *	stmt,
		const char *	queryString,
		Oid	relOid,
		Oid	refRelOid,
		Oid	constraintOid,
		Oid	indexOid,
		bool	isInternal
	)

Definition at line 141 of file trigger.c.

References AccessShareLock, ACL_EXECUTE, ACL_KIND_CLASS, ACL_KIND_PROC, ACL_TRIGGER, aclcheck_error(), ACLCHECK_OK, addRangeTableEntryForRelation(), addRTEtoQuery(), allowSystemTableMods, Anum_pg_trigger_tgargs, Anum_pg_trigger_tgattr, Anum_pg_trigger_tgconstraint, Anum_pg_trigger_tgconstrindid, Anum_pg_trigger_tgconstrrelid, Anum_pg_trigger_tgdeferrable, Anum_pg_trigger_tgenabled, Anum_pg_trigger_tgfoid, Anum_pg_trigger_tginitdeferred, Anum_pg_trigger_tgisinternal, Anum_pg_trigger_tgname, Anum_pg_trigger_tgnargs, Anum_pg_trigger_tgnewtable, Anum_pg_trigger_tgoldtable, Anum_pg_trigger_tgqual, Anum_pg_trigger_tgrelid, Anum_pg_trigger_tgtype, generate_unaccent_rules::args, CreateTrigStmt::args, Assert, assign_expr_collations(), attnameAttNum(), BoolGetDatum, BTEqualStrategyNumber, buildint2vector(), byteain(), CatalogTupleInsert(), CatalogTupleUpdate(), CharGetDatum, ObjectAddress::classId, CreateTrigStmt::columns, CONSTRAINT_TRIGGER, ConstraintRelationId, CreateTrigStmt::constrrel, ConvertTriggerToFK(), copyObject, CreateConstraintEntry(), CStringGetDatum, CStringGetTextDatum, DatumGetPointer, CreateTrigStmt::deferrable, DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, DEPENDENCY_NORMAL, DirectFunctionCall1, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errdetail(), errhint(), errmsg(), ERROR, CreateTrigStmt::events, EXPR_KIND_TRIGGER_WHEN, free_parsestate(), CreateTrigStmt::funcname, get_func_rettype(), get_rel_name(), GetNewOid(), GETSTRUCT, GetUserId(), has_superclass(), heap_close, heap_form_tuple(), heap_freetuple(), heap_open(), heap_openrv(), HeapTupleIsValid, HeapTupleSetOid, i, CreateTrigStmt::initdeferred, Int16GetDatum, InvalidAttrNumber, InvalidObjectAddress, InvalidOid, InvokeObjectPostCreateHookArg, CreateTrigStmt::isconstraint, TriggerTransition::isNew, IsSystemRelation(), TriggerTransition::isTable, lfirst, lfirst_node, list_length(), Var::location, LockRelationOid(), LookupFuncName(), make_parsestate(), makeAlias(), name, TriggerTransition::name, NAMEDATALEN, namein(), NameListToString(), namestrcmp(), Natts_pg_trigger, NIL, nodeToString(), NoLock, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, OPAQUEOID, ParseState::p_rtable, ParseState::p_sourcetext, palloc(), parser_errposition(), pfree(), pg_class_aclcheck(), pg_proc_aclcheck(), PointerGetDatum, ProcedureRelationId, PRS2_NEW_VARNO, PRS2_OLD_VARNO, pull_var_clause(), RangeVarGetRelid, RelationData::rd_att, RelationData::rd_id, RelationData::rd_rel, recordDependencyOn(), recordDependencyOnExpr(), CreateTrigStmt::relation, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, RelationRelationId, RELKIND_FOREIGN_TABLE, RELKIND_PARTITIONED_TABLE, RELKIND_RELATION, RELKIND_VIEW, RELOID, RI_FKey_trigger_type(), RI_TRIGGER_NONE, CreateTrigStmt::row, RowExclusiveLock, ScanKeyInit(), SearchSysCacheCopy1, SetFunctionReturnType(), ShareRowExclusiveLock, snprintf(), strVal, systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, CreateTrigStmt::timing, transformWhereClause(), CreateTrigStmt::transitionRels, TRIGGER_CLEAR_TYPE, TRIGGER_FIRES_ON_ORIGIN, TRIGGER_FOR_BEFORE, TRIGGER_FOR_DELETE, TRIGGER_FOR_INSERT, TRIGGER_FOR_INSTEAD, TRIGGER_FOR_ROW, TRIGGER_FOR_TRUNCATE, TRIGGER_FOR_UPDATE, TRIGGER_SETT_ROW, TRIGGER_TYPE_AFTER, TRIGGER_TYPE_BEFORE, TRIGGER_TYPE_INSTEAD, TRIGGEROID, TriggerRelationId, TriggerRelidNameIndexId, CreateTrigStmt::trigname, values, Var::varattno, Var::varno, WARNING, and CreateTrigStmt::whenClause.

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

 {
     int16       tgtype;
     int         ncolumns;
     int16      *columns;
     int2vector *tgattr;
     Node       *whenClause;
     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         fargtypes[1];   /* dummy */
     Oid         funcoid;
     Oid         funcrettype;
     Oid         trigoid;
     char        internaltrigname[NAMEDATALEN];
     char       *trigname;
     Oid         constrrelid = InvalidOid;
     ObjectAddress myself,
                 referenced;
     char       *oldtablename = NULL;
     char       *newtablename = NULL;
 
     if (OidIsValid(relOid))
         rel = heap_open(relOid, ShareRowExclusiveLock);
     else
         rel = heap_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 ||
         rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
     {
         /* 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.")));
         /* Disallow ROW triggers on partitioned tables */
         if (stmt->row && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("\"%s\" is a partitioned table",
                             RelationGetRelationName(rel)),
                      errdetail("Partitioned tables cannot have ROW triggers.")));
     }
     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, ACL_KIND_CLASS,
                            RelationGetRelationName(rel));
 
         if (OidIsValid(constrrelid))
         {
             aclresult = pg_class_aclcheck(constrrelid, GetUserId(),
                                           ACL_TRIGGER);
             if (aclresult != ACLCHECK_OK)
                 aclcheck_error(aclresult, ACL_KIND_CLASS,
                                get_rel_name(constrrelid));
         }
     }
 
     /* 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
      */
     if (stmt->whenClause)
     {
         ParseState *pstate;
         RangeTblEntry *rte;
         List       *varList;
         ListCell   *lc;
 
         /* Set up a pstate to parse with */
         pstate = make_parsestate(NULL);
         pstate->p_sourcetext = queryString;
 
         /*
          * Set up RTEs for OLD and NEW references.
          *
          * 'OLD' must always have varno equal to 1 and 'NEW' equal to 2.
          */
         rte = addRangeTableEntryForRelation(pstate, rel,
                                             makeAlias("old", NIL),
                                             false, false);
         addRTEtoQuery(pstate, rte, false, true, true);
         rte = addRangeTableEntryForRelation(pstate, rel,
                                             makeAlias("new", NIL),
                                             false, false);
         addRTEtoQuery(pstate, rte, 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)));
                     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
     {
         whenClause = NULL;
         whenRtable = NIL;
         qual = NULL;
     }
 
     /*
      * Find and validate the trigger function.
      */
     funcoid = LookupFuncName(stmt->funcname, 0, fargtypes, false);
     if (!isInternal)
     {
         aclresult = pg_proc_aclcheck(funcoid, GetUserId(), ACL_EXECUTE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, ACL_KIND_PROC,
                            NameListToString(stmt->funcname));
     }
     funcrettype = get_func_rettype(funcoid);
     if (funcrettype != TRIGGEROID)
     {
         /*
          * We allow OPAQUE just so we can load old dump files.  When we see a
          * trigger function declared OPAQUE, change it to TRIGGER.
          */
         if (funcrettype == OPAQUEOID)
         {
             ereport(WARNING,
                     (errmsg("changing return type of function %s from %s to %s",
                             NameListToString(stmt->funcname),
                             "opaque", "trigger")));
             SetFunctionReturnType(funcoid, TRIGGEROID);
         }
         else
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("function %s must return type %s",
                             NameListToString(stmt->funcname), "trigger")));
     }
 
     /*
      * If the command is a user-entered CREATE CONSTRAINT TRIGGER command that
      * references one of the built-in RI_FKey trigger functions, assume it is
      * from a dump of a pre-7.3 foreign key constraint, and take steps to
      * convert this legacy representation into a regular foreign key
      * constraint.  Ugly, but necessary for loading old dump files.
      */
     if (stmt->isconstraint && !isInternal &&
         list_length(stmt->args) >= 6 &&
         (list_length(stmt->args) % 2) == 0 &&
         RI_FKey_trigger_type(funcoid) != RI_TRIGGER_NONE)
     {
         /* Keep lock on target rel until end of xact */
         heap_close(rel, NoLock);
 
         ConvertTriggerToFK(stmt, funcoid);
 
         return InvalidObjectAddress;
     }
 
     /*
      * 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,
                                               RelationGetRelid(rel),
                                               NULL, /* no conkey */
                                               0,
                                               InvalidOid,   /* no domain */
                                               InvalidOid,   /* no index */
                                               InvalidOid,   /* no foreign key */
                                               NULL,
                                               NULL,
                                               NULL,
                                               NULL,
                                               0,
                                               ' ',
                                               ' ',
                                               ' ',
                                               NULL, /* no exclusion */
                                               NULL, /* no check constraint */
                                               NULL,
                                               NULL,
                                               true, /* islocal */
                                               0,    /* inhcount */
                                               true, /* isnoinherit */
                                               isInternal);  /* is_internal */
     }
 
     /*
      * Generate the trigger's OID now, so that we can use it in the name if
      * needed.
      */
     tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
 
     trigoid = GetNewOid(tgrel);
 
     /*
      * 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.
      */
     memset(nulls, false, sizeof(nulls));
 
     values[Anum_pg_trigger_tgrelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
     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);
     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);
 
     /* force tuple to have the desired OID */
     HeapTupleSetOid(tuple, trigoid);
 
     /*
      * Insert tuple into pg_trigger.
      */
     CatalogTupleInsert(tgrel, tuple);
 
     heap_freetuple(tuple);
     heap_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.  Crucial side-effect: other backends
      * (and this one too!) are sent SI message to make them rebuild relcache
      * entries.
      */
     pgrel = heap_open(RelationRelationId, RowExclusiveLock);
     tuple = SearchSysCacheCopy1(RELOID,
                                 ObjectIdGetDatum(RelationGetRelid(rel)));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "cache lookup failed for relation %u",
              RelationGetRelid(rel));
 
     ((Form_pg_class) GETSTRUCT(tuple))->relhastriggers = true;
 
     CatalogTupleUpdate(pgrel, &tuple->t_self, tuple);
 
     heap_freetuple(tuple);
     heap_close(pgrel, RowExclusiveLock);
 
     /*
      * We used to try to update the rel's relcache entry here, but that's
      * fairly pointless since it will happen as a byproduct of the upcoming
      * CommandCounterIncrement...
      */
 
     /*
      * 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 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 (whenClause != NULL)
         recordDependencyOnExpr(&myself, whenClause, whenRtable,
                                DEPENDENCY_NORMAL);
 
     /* Post creation hook for new trigger */
     InvokeObjectPostCreateHookArg(TriggerRelationId, trigoid, 0,
                                   isInternal);
 
     /* Keep lock on target rel until end of xact */
     heap_close(rel, NoLock);
 
     return myself;
 }

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

Definition at line 1581 of file trigger.c.

References Anum_pg_trigger_tgname, Anum_pg_trigger_tgrelid, BTEqualStrategyNumber, CacheInvalidateRelcache(), CatalogTupleUpdate(), CStringGetDatum, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_close, heap_copytuple(), heap_freetuple(), heap_open(), HeapTupleGetOid, HeapTupleIsValid, InvokeObjectPostAlterHook, NameStr, ObjectIdGetDatum, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), superuser(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, TriggerRelationId, and TriggerRelidNameIndexId.

Referenced by ATExecEnableDisableTrigger().

 {
     Relation    tgrel;
     int         nkeys;
     ScanKeyData keys[2];
     SysScanDesc tgscan;
     HeapTuple   tuple;
     bool        found;
     bool        changed;
 
     /* Scan the relevant entries in pg_triggers */
     tgrel = heap_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);
 
             changed = true;
         }
 
         InvokeObjectPostAlterHook(TriggerRelationId,
                                   HeapTupleGetOid(tuple), 0);
     }
 
     systable_endscan(tgscan);
 
     heap_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);
 }

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

Definition at line 2572 of file trigger.c.

References AfterTriggerSaveEvent(), Assert, GetTupleForTrigger(), heap_freetuple(), 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;
 
     if ((trigdesc && trigdesc->trig_delete_after_row) ||
         (transition_capture && transition_capture->tcs_delete_old_table))
     {
         HeapTuple   trigtuple;
 
         Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
         if (fdw_trigtuple == NULL)
             trigtuple = GetTupleForTrigger(estate,
                                            NULL,
                                            relinfo,
                                            tupleid,
                                            LockTupleExclusive,
                                            NULL);
         else
             trigtuple = fdw_trigtuple;
 
         AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_DELETE,
                               true, trigtuple, NULL, NIL, NULL,
                               transition_capture);
         if (trigtuple != fdw_trigtuple)
             heap_freetuple(trigtuple);
     }
 }

void ExecARInsertTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo,
		HeapTuple	trigtuple,
		List *	recheckIndexes,
		TransitionCaptureState *	transition_capture
	)

Definition at line 2354 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(), CopyFromInsertBatch(), 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, trigtuple,
                               recheckIndexes, NULL,
                               transition_capture);
 }

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

Definition at line 2841 of file trigger.c.

References AfterTriggerSaveEvent(), Assert, GetTupleForTrigger(), GetUpdatedColumns, heap_freetuple(), HeapTupleIsValid, 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 ExecSimpleRelationUpdate(), and ExecUpdate().

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
 
     if ((trigdesc && trigdesc->trig_update_after_row) ||
         (transition_capture &&
          (transition_capture->tcs_update_old_table ||
           transition_capture->tcs_update_new_table)))
     {
         HeapTuple   trigtuple;
 
         Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
         if (fdw_trigtuple == NULL)
             trigtuple = GetTupleForTrigger(estate,
                                            NULL,
                                            relinfo,
                                            tupleid,
                                            LockTupleExclusive,
                                            NULL);
         else
             trigtuple = fdw_trigtuple;
 
         AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_UPDATE,
                               true, trigtuple, newtuple, recheckIndexes,
                               GetUpdatedColumns(relinfo, estate),
                               transition_capture);
         if (trigtuple != fdw_trigtuple)
             heap_freetuple(trigtuple);
     }
 }

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

Definition at line 2492 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);
 }

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

Definition at line 2277 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);
 }

void ExecASTruncateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2996 of file trigger.c.

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

Referenced by ExecuteTruncate().

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

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

Definition at line 2711 of file trigger.c.

References AfterTriggerSaveEvent(), GetUpdatedColumns, 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,
                               GetUpdatedColumns(relinfo, estate),
                               transition_capture);
 }

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

Definition at line 2503 of file trigger.c.

References Assert, ExecCallTriggerFunc(), GetPerTupleMemoryContext, GetTupleForTrigger(), heap_freetuple(), HeapTupleIsValid, i, InvalidBuffer, ItemPointerIsValid, LockTupleExclusive, TriggerDesc::numtriggers, result, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_DELETE, TRIGGER_EVENT_ROW, TRIGGER_TYPE_BEFORE, TRIGGER_TYPE_DELETE, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_ROW, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by ExecDelete(), and ExecSimpleRelationDelete().

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     bool        result = true;
     TriggerData LocTriggerData;
     HeapTuple   trigtuple;
     HeapTuple   newtuple;
     TupleTableSlot *newSlot;
     int         i;
 
     Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
     if (fdw_trigtuple == NULL)
     {
         trigtuple = GetTupleForTrigger(estate, epqstate, relinfo, tupleid,
                                        LockTupleExclusive, &newSlot);
         if (trigtuple == NULL)
             return false;
     }
     else
         trigtuple = fdw_trigtuple;
 
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_DELETE |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     LocTriggerData.tg_newtuple = NULL;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     LocTriggerData.tg_newtuplebuf = InvalidBuffer;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         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, trigtuple, NULL))
             continue;
 
         LocTriggerData.tg_trigtuple = trigtuple;
         LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
         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 (trigtuple != fdw_trigtuple)
         heap_freetuple(trigtuple);
 
     return result;
 }

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

Definition at line 2288 of file trigger.c.

References EState::es_trig_tuple_slot, ExecCallTriggerFunc(), ExecMaterializeSlot(), ExecSetSlotDescriptor(), ExecStoreTuple(), GetPerTupleMemoryContext, heap_freetuple(), i, InvalidBuffer, TriggerDesc::numtriggers, RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_INSERT, TRIGGER_EVENT_ROW, TRIGGER_TYPE_BEFORE, TRIGGER_TYPE_INSERT, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_ROW, TriggerEnabled(), TriggerDesc::triggers, TupleTableSlot::tts_tupleDescriptor, and TriggerData::type.

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

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     HeapTuple   slottuple = ExecMaterializeSlot(slot);
     HeapTuple   newtuple = slottuple;
     HeapTuple   oldtuple;
     TriggerData LocTriggerData;
     int         i;
 
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_INSERT |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     LocTriggerData.tg_newtuple = NULL;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     LocTriggerData.tg_newtuplebuf = InvalidBuffer;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
 
         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, newtuple))
             continue;
 
         LocTriggerData.tg_trigtuple = oldtuple = newtuple;
         LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
         if (oldtuple != newtuple && oldtuple != slottuple)
             heap_freetuple(oldtuple);
         if (newtuple == NULL)
             return NULL;        /* "do nothing" */
     }
 
     if (newtuple != slottuple)
     {
         /*
          * Return the modified tuple using the es_trig_tuple_slot.  We assume
          * the tuple was allocated in per-tuple memory context, and therefore
          * will go away by itself. The tuple table slot should not try to
          * clear it.
          */
         TupleTableSlot *newslot = estate->es_trig_tuple_slot;
         TupleDesc   tupdesc = RelationGetDescr(relinfo->ri_RelationDesc);
 
         if (newslot->tts_tupleDescriptor != tupdesc)
             ExecSetSlotDescriptor(newslot, tupdesc);
         ExecStoreTuple(newtuple, newslot, InvalidBuffer, false);
         slot = newslot;
     }
     return slot;
 }

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

Definition at line 2724 of file trigger.c.

References Assert, EState::es_trig_tuple_slot, ExecCallTriggerFunc(), ExecFilterJunk(), ExecMaterializeSlot(), ExecSetSlotDescriptor(), ExecStoreTuple(), ExecUpdateLockMode(), GetPerTupleMemoryContext, GetTupleForTrigger(), GetUpdatedColumns, heap_freetuple(), HeapTupleIsValid, i, InvalidBuffer, ItemPointerIsValid, TriggerDesc::numtriggers, RelationGetDescr, ResultRelInfo::ri_junkFilter, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_ROW, TRIGGER_EVENT_UPDATE, TRIGGER_TYPE_BEFORE, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_ROW, TRIGGER_TYPE_UPDATE, TriggerEnabled(), TriggerDesc::triggers, TupleTableSlot::tts_tupleDescriptor, and TriggerData::type.

Referenced by ExecSimpleRelationUpdate(), and ExecUpdate().

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     HeapTuple   slottuple = ExecMaterializeSlot(slot);
     HeapTuple   newtuple = slottuple;
     TriggerData LocTriggerData;
     HeapTuple   trigtuple;
     HeapTuple   oldtuple;
     TupleTableSlot *newSlot;
     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)
     {
         /* get a copy of the on-disk tuple we are planning to update */
         trigtuple = GetTupleForTrigger(estate, epqstate, relinfo, tupleid,
                                        lockmode, &newSlot);
         if (trigtuple == NULL)
             return NULL;        /* cancel the update action */
     }
     else
     {
         trigtuple = fdw_trigtuple;
         newSlot = NULL;
     }
 
     /*
      * 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 newSlot, 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 (newSlot != NULL)
     {
         slot = ExecFilterJunk(relinfo->ri_junkFilter, newSlot);
         slottuple = ExecMaterializeSlot(slot);
         newtuple = slottuple;
     }
 
 
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_UPDATE |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     updatedCols = GetUpdatedColumns(relinfo, estate);
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
 
         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, trigtuple, newtuple))
             continue;
 
         LocTriggerData.tg_trigtuple = trigtuple;
         LocTriggerData.tg_newtuple = oldtuple = newtuple;
         LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
         LocTriggerData.tg_newtuplebuf = InvalidBuffer;
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
         if (oldtuple != newtuple && oldtuple != slottuple)
             heap_freetuple(oldtuple);
         if (newtuple == NULL)
         {
             if (trigtuple != fdw_trigtuple)
                 heap_freetuple(trigtuple);
             return NULL;        /* "do nothing" */
         }
     }
     if (trigtuple != fdw_trigtuple)
         heap_freetuple(trigtuple);
 
     if (newtuple != slottuple)
     {
         /*
          * Return the modified tuple using the es_trig_tuple_slot.  We assume
          * the tuple was allocated in per-tuple memory context, and therefore
          * will go away by itself. The tuple table slot should not try to
          * clear it.
          */
         TupleTableSlot *newslot = estate->es_trig_tuple_slot;
         TupleDesc   tupdesc = RelationGetDescr(relinfo->ri_RelationDesc);
 
         if (newslot->tts_tupleDescriptor != tupdesc)
             ExecSetSlotDescriptor(newslot, tupdesc);
         ExecStoreTuple(newtuple, newslot, InvalidBuffer, false);
         slot = newslot;
     }
     return slot;
 }

void ExecBSDeleteTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2435 of file trigger.c.

References before_stmt_triggers_fired(), CMD_DELETE, ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), GetPerTupleMemoryContext, i, InvalidBuffer, TriggerDesc::numtriggers, RelationGetRelid, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TriggerDesc::trig_delete_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_DELETE, TRIGGER_TYPE_BEFORE, TRIGGER_TYPE_DELETE, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_STATEMENT, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by fireBSTriggers().

 {
     TriggerDesc *trigdesc;
     int         i;
     TriggerData LocTriggerData;
 
     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;
     LocTriggerData.tg_trigtuple = NULL;
     LocTriggerData.tg_newtuple = NULL;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
     LocTriggerData.tg_newtuplebuf = InvalidBuffer;
     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")));
     }
 }

void ExecBSInsertTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2220 of file trigger.c.

References before_stmt_triggers_fired(), CMD_INSERT, ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), GetPerTupleMemoryContext, i, InvalidBuffer, TriggerDesc::numtriggers, RelationGetRelid, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TriggerDesc::trig_insert_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_INSERT, TRIGGER_TYPE_BEFORE, TRIGGER_TYPE_INSERT, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_STATEMENT, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by CopyFrom(), and fireBSTriggers().

 {
     TriggerDesc *trigdesc;
     int         i;
     TriggerData LocTriggerData;
 
     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;
     LocTriggerData.tg_trigtuple = NULL;
     LocTriggerData.tg_newtuple = NULL;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
     LocTriggerData.tg_newtuplebuf = InvalidBuffer;
     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")));
     }
 }

void ExecBSTruncateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2944 of file trigger.c.

References ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), GetPerTupleMemoryContext, i, InvalidBuffer, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TriggerDesc::trig_truncate_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_TRUNCATE, TRIGGER_TYPE_BEFORE, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_STATEMENT, TRIGGER_TYPE_TRUNCATE, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by ExecuteTruncate().

 {
     TriggerDesc *trigdesc;
     int         i;
     TriggerData LocTriggerData;
 
     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;
     LocTriggerData.tg_trigtuple = NULL;
     LocTriggerData.tg_newtuple = NULL;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
     LocTriggerData.tg_newtuplebuf = InvalidBuffer;
     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")));
     }
 }

void ExecBSUpdateTriggers	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2651 of file trigger.c.

References before_stmt_triggers_fired(), CMD_UPDATE, ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), GetPerTupleMemoryContext, GetUpdatedColumns, i, InvalidBuffer, TriggerDesc::numtriggers, RelationGetRelid, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TriggerDesc::trig_update_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_UPDATE, TRIGGER_TYPE_BEFORE, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_STATEMENT, TRIGGER_TYPE_UPDATE, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by fireBSTriggers().

 {
     TriggerDesc *trigdesc;
     int         i;
     TriggerData LocTriggerData;
     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 = GetUpdatedColumns(relinfo, estate);
 
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_UPDATE |
         TRIGGER_EVENT_BEFORE;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     LocTriggerData.tg_trigtuple = NULL;
     LocTriggerData.tg_newtuple = NULL;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
     LocTriggerData.tg_newtuplebuf = InvalidBuffer;
     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")));
     }
 }

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

Definition at line 2604 of file trigger.c.

References ExecCallTriggerFunc(), GetPerTupleMemoryContext, heap_freetuple(), i, InvalidBuffer, TriggerDesc::numtriggers, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TRIGGER_EVENT_DELETE, TRIGGER_EVENT_INSTEAD, TRIGGER_EVENT_ROW, TRIGGER_TYPE_DELETE, TRIGGER_TYPE_INSTEAD, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_ROW, TriggerEnabled(), TriggerDesc::triggers, and TriggerData::type.

Referenced by ExecDelete().

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     TriggerData LocTriggerData;
     HeapTuple   rettuple;
     int         i;
 
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_DELETE |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_INSTEAD;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     LocTriggerData.tg_newtuple = NULL;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     LocTriggerData.tg_newtuplebuf = InvalidBuffer;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         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, trigtuple, NULL))
             continue;
 
         LocTriggerData.tg_trigtuple = trigtuple;
         LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
         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;
 }

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

Definition at line 2369 of file trigger.c.

References EState::es_trig_tuple_slot, ExecCallTriggerFunc(), ExecMaterializeSlot(), ExecSetSlotDescriptor(), ExecStoreTuple(), GetPerTupleMemoryContext, heap_freetuple(), i, InvalidBuffer, TriggerDesc::numtriggers, RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TRIGGER_EVENT_INSERT, TRIGGER_EVENT_INSTEAD, TRIGGER_EVENT_ROW, TRIGGER_TYPE_INSERT, TRIGGER_TYPE_INSTEAD, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_ROW, TriggerEnabled(), TriggerDesc::triggers, TupleTableSlot::tts_tupleDescriptor, and TriggerData::type.

Referenced by CopyFrom(), and ExecInsert().

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     HeapTuple   slottuple = ExecMaterializeSlot(slot);
     HeapTuple   newtuple = slottuple;
     HeapTuple   oldtuple;
     TriggerData LocTriggerData;
     int         i;
 
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_INSERT |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_INSTEAD;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     LocTriggerData.tg_newtuple = NULL;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     LocTriggerData.tg_newtuplebuf = InvalidBuffer;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
 
         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, newtuple))
             continue;
 
         LocTriggerData.tg_trigtuple = oldtuple = newtuple;
         LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
         if (oldtuple != newtuple && oldtuple != slottuple)
             heap_freetuple(oldtuple);
         if (newtuple == NULL)
             return NULL;        /* "do nothing" */
     }
 
     if (newtuple != slottuple)
     {
         /*
          * Return the modified tuple using the es_trig_tuple_slot.  We assume
          * the tuple was allocated in per-tuple memory context, and therefore
          * will go away by itself. The tuple table slot should not try to
          * clear it.
          */
         TupleTableSlot *newslot = estate->es_trig_tuple_slot;
         TupleDesc   tupdesc = RelationGetDescr(relinfo->ri_RelationDesc);
 
         if (newslot->tts_tupleDescriptor != tupdesc)
             ExecSetSlotDescriptor(newslot, tupdesc);
         ExecStoreTuple(newtuple, newslot, InvalidBuffer, false);
         slot = newslot;
     }
     return slot;
 }

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

Definition at line 2878 of file trigger.c.

References EState::es_trig_tuple_slot, ExecCallTriggerFunc(), ExecMaterializeSlot(), ExecSetSlotDescriptor(), ExecStoreTuple(), GetPerTupleMemoryContext, heap_freetuple(), i, InvalidBuffer, TriggerDesc::numtriggers, RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, T_TriggerData, TriggerData::tg_event, TriggerData::tg_newtable, TriggerData::tg_newtuple, TriggerData::tg_newtuplebuf, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, TriggerData::tg_trigtuplebuf, Trigger::tgtype, TRIGGER_EVENT_INSTEAD, TRIGGER_EVENT_ROW, TRIGGER_EVENT_UPDATE, TRIGGER_TYPE_INSTEAD, TRIGGER_TYPE_MATCHES, TRIGGER_TYPE_ROW, TRIGGER_TYPE_UPDATE, TriggerEnabled(), TriggerDesc::triggers, TupleTableSlot::tts_tupleDescriptor, and TriggerData::type.

Referenced by ExecUpdate().

 {
     TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
     HeapTuple   slottuple = ExecMaterializeSlot(slot);
     HeapTuple   newtuple = slottuple;
     TriggerData LocTriggerData;
     HeapTuple   oldtuple;
     int         i;
 
     LocTriggerData.type = T_TriggerData;
     LocTriggerData.tg_event = TRIGGER_EVENT_UPDATE |
         TRIGGER_EVENT_ROW |
         TRIGGER_EVENT_INSTEAD;
     LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
     LocTriggerData.tg_oldtable = NULL;
     LocTriggerData.tg_newtable = NULL;
     for (i = 0; i < trigdesc->numtriggers; i++)
     {
         Trigger    *trigger = &trigdesc->triggers[i];
 
         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, trigtuple, newtuple))
             continue;
 
         LocTriggerData.tg_trigtuple = trigtuple;
         LocTriggerData.tg_newtuple = oldtuple = newtuple;
         LocTriggerData.tg_trigtuplebuf = InvalidBuffer;
         LocTriggerData.tg_newtuplebuf = InvalidBuffer;
         LocTriggerData.tg_trigger = trigger;
         newtuple = ExecCallTriggerFunc(&LocTriggerData,
                                        i,
                                        relinfo->ri_TrigFunctions,
                                        relinfo->ri_TrigInstrument,
                                        GetPerTupleMemoryContext(estate));
         if (oldtuple != newtuple && oldtuple != slottuple)
             heap_freetuple(oldtuple);
         if (newtuple == NULL)
             return NULL;        /* "do nothing" */
     }
 
     if (newtuple != slottuple)
     {
         /*
          * Return the modified tuple using the es_trig_tuple_slot.  We assume
          * the tuple was allocated in per-tuple memory context, and therefore
          * will go away by itself. The tuple table slot should not try to
          * clear it.
          */
         TupleTableSlot *newslot = estate->es_trig_tuple_slot;
         TupleDesc   tupdesc = RelationGetDescr(relinfo->ri_RelationDesc);
 
         if (newslot->tts_tupleDescriptor != tupdesc)
             ExecSetSlotDescriptor(newslot, tupdesc);
         ExecStoreTuple(newtuple, newslot, InvalidBuffer, false);
         slot = newslot;
     }
     return slot;
 }

const char* FindTriggerIncompatibleWithInheritance ( TriggerDesc * trigdesc )

Definition at line 2096 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;
 }

void FreeTriggerDesc ( TriggerDesc * trigdesc )

Definition at line 1966 of file trigger.c.

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

Referenced by RelationBuildTriggers(), and RelationDestroyRelation().

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

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

Definition at line 1353 of file trigger.c.

References AccessShareLock, Anum_pg_trigger_tgname, Anum_pg_trigger_tgrelid, BTEqualStrategyNumber, CStringGetDatum, ereport, errcode(), errmsg(), ERROR, get_rel_name(), heap_close, heap_open(), HeapTupleGetOid, HeapTupleIsValid, InvalidOid, ObjectIdGetDatum, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), TriggerRelationId, 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 = heap_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 = HeapTupleGetOid(tup);
     }
 
     systable_endscan(tgscan);
     heap_close(tgrel, AccessShareLock);
     return oid;
 }

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

Definition at line 4411 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(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, 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;
     PG_TRY();
     {
         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);
     }
     PG_CATCH();
     {
         CurrentResourceOwner = saveResourceOwner;
         PG_RE_THROW();
     }
     PG_END_TRY();
     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;
 }

void RelationBuildTriggers ( Relation relation )

Definition at line 1683 of file trigger.c.

References AccessShareLock, Anum_pg_trigger_tgargs, Anum_pg_trigger_tgnewtable, Anum_pg_trigger_tgoldtable, Anum_pg_trigger_tgqual, Anum_pg_trigger_tgrelid, BTEqualStrategyNumber, CacheMemoryContext, CopyTriggerDesc(), DatumGetByteaPP, DatumGetCString, DirectFunctionCall1, elog, ERROR, fastgetattr, FreeTriggerDesc(), GETSTRUCT, heap_close, heap_open(), HeapTupleGetOid, HeapTupleIsValid, i, MemoryContextSwitchTo(), NameGetDatum, nameout(), TriggerDesc::numtriggers, ObjectIdGetDatum, palloc(), palloc0(), pfree(), pstrdup(), RelationData::rd_att, RelationGetRelationName, RelationGetRelid, repalloc(), ScanKeyInit(), SetTriggerFlags(), systable_beginscan(), systable_endscan(), systable_getnext(), TextDatumGetCString, Trigger::tgargs, Trigger::tgattr, Trigger::tgconstraint, Trigger::tgconstrindid, Trigger::tgconstrrelid, Trigger::tgdeferrable, Trigger::tgenabled, Trigger::tgfoid, Trigger::tginitdeferred, Trigger::tgisinternal, Trigger::tgname, Trigger::tgnargs, Trigger::tgnattr, Trigger::tgnewtable, Trigger::tgoid, Trigger::tgoldtable, Trigger::tgqual, Trigger::tgtype, RelationData::trigdesc, TriggerRelationId, 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  

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation