PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Functions | Variables
trigger.h File Reference
#include "access/tableam.h"
#include "catalog/objectaddress.h"
#include "nodes/execnodes.h"
#include "nodes/parsenodes.h"
Include dependency graph for trigger.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  TriggerData
 
struct  TransitionCaptureState
 

Macros

#define CALLED_AS_TRIGGER(fcinfo)    ((fcinfo)->context != NULL && IsA((fcinfo)->context, TriggerData))
 
#define TRIGGER_EVENT_INSERT   0x00000000
 
#define TRIGGER_EVENT_DELETE   0x00000001
 
#define TRIGGER_EVENT_UPDATE   0x00000002
 
#define TRIGGER_EVENT_TRUNCATE   0x00000003
 
#define TRIGGER_EVENT_OPMASK   0x00000003
 
#define TRIGGER_EVENT_ROW   0x00000004
 
#define TRIGGER_EVENT_BEFORE   0x00000008
 
#define TRIGGER_EVENT_AFTER   0x00000000
 
#define TRIGGER_EVENT_INSTEAD   0x00000010
 
#define TRIGGER_EVENT_TIMINGMASK   0x00000018
 
#define AFTER_TRIGGER_DEFERRABLE   0x00000020
 
#define AFTER_TRIGGER_INITDEFERRED   0x00000040
 
#define TRIGGER_FIRED_BY_INSERT(event)    (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_INSERT)
 
#define TRIGGER_FIRED_BY_DELETE(event)    (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_DELETE)
 
#define TRIGGER_FIRED_BY_UPDATE(event)    (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_UPDATE)
 
#define TRIGGER_FIRED_BY_TRUNCATE(event)    (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_TRUNCATE)
 
#define TRIGGER_FIRED_FOR_ROW(event)    ((event) & TRIGGER_EVENT_ROW)
 
#define TRIGGER_FIRED_FOR_STATEMENT(event)    (!TRIGGER_FIRED_FOR_ROW(event))
 
#define TRIGGER_FIRED_BEFORE(event)    (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_BEFORE)
 
#define TRIGGER_FIRED_AFTER(event)    (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_AFTER)
 
#define TRIGGER_FIRED_INSTEAD(event)    (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_INSTEAD)
 
#define SESSION_REPLICATION_ROLE_ORIGIN   0
 
#define SESSION_REPLICATION_ROLE_REPLICA   1
 
#define SESSION_REPLICATION_ROLE_LOCAL   2
 
#define TRIGGER_FIRES_ON_ORIGIN   'O'
 
#define TRIGGER_FIRES_ALWAYS   'A'
 
#define TRIGGER_FIRES_ON_REPLICA   'R'
 
#define TRIGGER_DISABLED   'D'
 
#define RI_TRIGGER_PK   1 /* is a trigger on the PK relation */
 
#define RI_TRIGGER_FK   2 /* is a trigger on the FK relation */
 
#define RI_TRIGGER_NONE   0 /* is not an RI trigger function */
 

Typedefs

typedef uint32 TriggerEvent
 
typedef struct TriggerData TriggerData
 
typedef struct TransitionCaptureState TransitionCaptureState
 

Functions

ObjectAddress CreateTrigger (CreateTrigStmt *stmt, const char *queryString, Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid funcoid, Oid parentTriggerOid, Node *whenClause, bool isInternal, bool in_partition)
 
ObjectAddress CreateTriggerFiringOn (CreateTrigStmt *stmt, const char *queryString, Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid funcoid, Oid parentTriggerOid, Node *whenClause, bool isInternal, bool in_partition, char trigger_fires_when)
 
void TriggerSetParentTrigger (Relation trigRel, Oid childTrigId, Oid parentTrigId, Oid childTableId)
 
void RemoveTriggerById (Oid trigOid)
 
Oid get_trigger_oid (Oid relid, const char *trigname, bool missing_ok)
 
ObjectAddress renametrig (RenameStmt *stmt)
 
void EnableDisableTrigger (Relation rel, const char *tgname, Oid tgparent, char fires_when, bool skip_system, bool recurse, LOCKMODE lockmode)
 
void RelationBuildTriggers (Relation relation)
 
TriggerDesc * CopyTriggerDesc (TriggerDesc *trigdesc)
 
const char * FindTriggerIncompatibleWithInheritance (TriggerDesc *trigdesc)
 
TransitionCaptureState * MakeTransitionCaptureState (TriggerDesc *trigdesc, Oid relid, CmdType cmdType)
 
void FreeTriggerDesc (TriggerDesc *trigdesc)
 
void ExecBSInsertTriggers (EState *estate, ResultRelInfo *relinfo)
 
void ExecASInsertTriggers (EState *estate, ResultRelInfo *relinfo, TransitionCaptureState *transition_capture)
 
bool ExecBRInsertTriggers (EState *estate, ResultRelInfo *relinfo, TupleTableSlot *slot)
 
void ExecARInsertTriggers (EState *estate, ResultRelInfo *relinfo, TupleTableSlot *slot, List *recheckIndexes, TransitionCaptureState *transition_capture)
 
bool ExecIRInsertTriggers (EState *estate, ResultRelInfo *relinfo, TupleTableSlot *slot)
 
void ExecBSDeleteTriggers (EState *estate, ResultRelInfo *relinfo)
 
void ExecASDeleteTriggers (EState *estate, ResultRelInfo *relinfo, TransitionCaptureState *transition_capture)
 
bool ExecBRDeleteTriggers (EState *estate, EPQState *epqstate, ResultRelInfo *relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot **epqslot, TM_Result *tmresult, TM_FailureData *tmfd, bool is_merge_delete)
 
void ExecARDeleteTriggers (EState *estate, ResultRelInfo *relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TransitionCaptureState *transition_capture, bool is_crosspart_update)
 
bool ExecIRDeleteTriggers (EState *estate, ResultRelInfo *relinfo, HeapTuple trigtuple)
 
void ExecBSUpdateTriggers (EState *estate, ResultRelInfo *relinfo)
 
void ExecASUpdateTriggers (EState *estate, ResultRelInfo *relinfo, TransitionCaptureState *transition_capture)
 
bool ExecBRUpdateTriggers (EState *estate, EPQState *epqstate, ResultRelInfo *relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot *newslot, TM_Result *tmresult, TM_FailureData *tmfd, bool is_merge_update)
 
void ExecARUpdateTriggers (EState *estate, ResultRelInfo *relinfo, ResultRelInfo *src_partinfo, ResultRelInfo *dst_partinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot *newslot, List *recheckIndexes, TransitionCaptureState *transition_capture, bool is_crosspart_update)
 
bool ExecIRUpdateTriggers (EState *estate, ResultRelInfo *relinfo, HeapTuple trigtuple, TupleTableSlot *newslot)
 
void ExecBSTruncateTriggers (EState *estate, ResultRelInfo *relinfo)
 
void ExecASTruncateTriggers (EState *estate, ResultRelInfo *relinfo)
 
void AfterTriggerBeginXact (void)
 
void AfterTriggerBeginQuery (void)
 
void AfterTriggerEndQuery (EState *estate)
 
void AfterTriggerFireDeferred (void)
 
void AfterTriggerEndXact (bool isCommit)
 
void AfterTriggerBeginSubXact (void)
 
void AfterTriggerEndSubXact (bool isCommit)
 
void AfterTriggerSetState (ConstraintsSetStmt *stmt)
 
bool AfterTriggerPendingOnRel (Oid relid)
 
bool RI_FKey_pk_upd_check_required (Trigger *trigger, Relation pk_rel, TupleTableSlot *oldslot, TupleTableSlot *newslot)
 
bool RI_FKey_fk_upd_check_required (Trigger *trigger, Relation fk_rel, TupleTableSlot *oldslot, TupleTableSlot *newslot)
 
bool RI_Initial_Check (Trigger *trigger, Relation fk_rel, Relation pk_rel)
 
void RI_PartitionRemove_Check (Trigger *trigger, Relation fk_rel, Relation pk_rel)
 
int RI_FKey_trigger_type (Oid tgfoid)
 

Variables

PGDLLIMPORT int SessionReplicationRole
 

Macro Definition Documentation

◆ AFTER_TRIGGER_DEFERRABLE

#define AFTER_TRIGGER_DEFERRABLE   0x00000020

Definition at line 107 of file trigger.h.

◆ AFTER_TRIGGER_INITDEFERRED

#define AFTER_TRIGGER_INITDEFERRED   0x00000040

Definition at line 108 of file trigger.h.

◆ CALLED_AS_TRIGGER

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

Definition at line 26 of file trigger.h.

◆ RI_TRIGGER_FK

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

Definition at line 285 of file trigger.h.

◆ RI_TRIGGER_NONE

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

Definition at line 286 of file trigger.h.

◆ RI_TRIGGER_PK

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

Definition at line 284 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_LOCAL

#define SESSION_REPLICATION_ROLE_LOCAL   2

Definition at line 142 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_ORIGIN

#define SESSION_REPLICATION_ROLE_ORIGIN   0

Definition at line 140 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_REPLICA

#define SESSION_REPLICATION_ROLE_REPLICA   1

Definition at line 141 of file trigger.h.

◆ TRIGGER_DISABLED

#define TRIGGER_DISABLED   'D'

Definition at line 152 of file trigger.h.

◆ TRIGGER_EVENT_AFTER

#define TRIGGER_EVENT_AFTER   0x00000000

Definition at line 101 of file trigger.h.

◆ TRIGGER_EVENT_BEFORE

#define TRIGGER_EVENT_BEFORE   0x00000008

Definition at line 100 of file trigger.h.

◆ TRIGGER_EVENT_DELETE

#define TRIGGER_EVENT_DELETE   0x00000001

Definition at line 93 of file trigger.h.

◆ TRIGGER_EVENT_INSERT

#define TRIGGER_EVENT_INSERT   0x00000000

Definition at line 92 of file trigger.h.

◆ TRIGGER_EVENT_INSTEAD

#define TRIGGER_EVENT_INSTEAD   0x00000010

Definition at line 102 of file trigger.h.

◆ TRIGGER_EVENT_OPMASK

#define TRIGGER_EVENT_OPMASK   0x00000003

Definition at line 96 of file trigger.h.

◆ TRIGGER_EVENT_ROW

#define TRIGGER_EVENT_ROW   0x00000004

Definition at line 98 of file trigger.h.

◆ TRIGGER_EVENT_TIMINGMASK

#define TRIGGER_EVENT_TIMINGMASK   0x00000018

Definition at line 103 of file trigger.h.

◆ TRIGGER_EVENT_TRUNCATE

#define TRIGGER_EVENT_TRUNCATE   0x00000003

Definition at line 95 of file trigger.h.

◆ TRIGGER_EVENT_UPDATE

#define TRIGGER_EVENT_UPDATE   0x00000002

Definition at line 94 of file trigger.h.

◆ TRIGGER_FIRED_AFTER

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

Definition at line 131 of file trigger.h.

◆ TRIGGER_FIRED_BEFORE

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

Definition at line 128 of file trigger.h.

◆ TRIGGER_FIRED_BY_DELETE

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

Definition at line 113 of file trigger.h.

◆ TRIGGER_FIRED_BY_INSERT

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

Definition at line 110 of file trigger.h.

◆ TRIGGER_FIRED_BY_TRUNCATE

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

Definition at line 119 of file trigger.h.

◆ TRIGGER_FIRED_BY_UPDATE

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

Definition at line 116 of file trigger.h.

◆ TRIGGER_FIRED_FOR_ROW

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

Definition at line 122 of file trigger.h.

◆ TRIGGER_FIRED_FOR_STATEMENT

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

Definition at line 125 of file trigger.h.

◆ TRIGGER_FIRED_INSTEAD

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

Definition at line 134 of file trigger.h.

◆ TRIGGER_FIRES_ALWAYS

#define TRIGGER_FIRES_ALWAYS   'A'

Definition at line 150 of file trigger.h.

◆ TRIGGER_FIRES_ON_ORIGIN

#define TRIGGER_FIRES_ON_ORIGIN   'O'

Definition at line 149 of file trigger.h.

◆ TRIGGER_FIRES_ON_REPLICA

#define TRIGGER_FIRES_ON_REPLICA   'R'

Definition at line 151 of file trigger.h.

Typedef Documentation

◆ TransitionCaptureState

typedef struct TransitionCaptureState TransitionCaptureState

◆ TriggerData

typedef struct TriggerData TriggerData

◆ TriggerEvent

typedef uint32 TriggerEvent

Definition at line 29 of file trigger.h.

Function Documentation

◆ AfterTriggerBeginQuery()

void AfterTriggerBeginQuery ( void  )

Definition at line 5104 of file trigger.c.

5105{
5106 /* Increase the query stack depth */
5107 afterTriggers.query_depth++;
5108}
afterTriggers
static AfterTriggersData afterTriggers
Definition: trigger.c:3941

References afterTriggers, and AfterTriggersData::query_depth.

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

◆ AfterTriggerBeginSubXact()

void AfterTriggerBeginSubXact ( void  )

Definition at line 5387 of file trigger.c.

5388{
5389 int my_level = GetCurrentTransactionNestLevel();
5390
5391 /*
5392 * Allocate more space in the trans_stack if needed. (Note: because the
5393 * minimum nest level of a subtransaction is 2, we waste the first couple
5394 * entries of the array; not worth the notational effort to avoid it.)
5395 */
5396 while (my_level >= afterTriggers.maxtransdepth)
5397 {
5398 if (afterTriggers.maxtransdepth == 0)
5399 {
5400 /* Arbitrarily initialize for max of 8 subtransaction levels */
5401 afterTriggers.trans_stack = (AfterTriggersTransData *)
5402 MemoryContextAlloc(TopTransactionContext,
5403 8 * sizeof(AfterTriggersTransData));
5404 afterTriggers.maxtransdepth = 8;
5405 }
5406 else
5407 {
5408 /* repalloc will keep the stack in the same context */
5409 int new_alloc = afterTriggers.maxtransdepth * 2;
5410
5411 afterTriggers.trans_stack = (AfterTriggersTransData *)
5412 repalloc(afterTriggers.trans_stack,
5413 new_alloc * sizeof(AfterTriggersTransData));
5414 afterTriggers.maxtransdepth = new_alloc;
5415 }
5416 }
5417
5418 /*
5419 * Push the current information into the stack. The SET CONSTRAINTS state
5420 * is not saved until/unless changed. Likewise, we don't make a
5421 * per-subtransaction event context until needed.
5422 */
5423 afterTriggers.trans_stack[my_level].state = NULL;
5424 afterTriggers.trans_stack[my_level].events = afterTriggers.events;
5425 afterTriggers.trans_stack[my_level].query_depth = afterTriggers.query_depth;
5426 afterTriggers.trans_stack[my_level].firing_counter = afterTriggers.firing_counter;
5427}
MemoryContextAlloc
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1229
TopTransactionContext
MemoryContext TopTransactionContext
Definition: mcxt.c:171
repalloc
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1610
AfterTriggersData::firing_counter
CommandId firing_counter
Definition: trigger.c:3881
AfterTriggersData::trans_stack
AfterTriggersTransData * trans_stack
Definition: trigger.c:3892
AfterTriggersData::events
AfterTriggerEventList events
Definition: trigger.c:3883
AfterTriggersTransData::events
AfterTriggerEventList events
Definition: trigger.c:3907
AfterTriggersTransData::state
SetConstraintState state
Definition: trigger.c:3906
AfterTriggersTransData::firing_counter
CommandId firing_counter
Definition: trigger.c:3909
GetCurrentTransactionNestLevel
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:930

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

Referenced by StartSubTransaction().

◆ AfterTriggerBeginXact()

void AfterTriggerBeginXact ( void  )

Definition at line 5072 of file trigger.c.

5073{
5074 /*
5075 * Initialize after-trigger state structure to empty
5076 */
5077 afterTriggers.firing_counter = (CommandId) 1; /* mustn't be 0 */
5078 afterTriggers.query_depth = -1;
5079
5080 /*
5081 * Verify that there is no leftover state remaining. If these assertions
5082 * trip, it means that AfterTriggerEndXact wasn't called or didn't clean
5083 * up properly.
5084 */
5085 Assert(afterTriggers.state == NULL);
5086 Assert(afterTriggers.query_stack == NULL);
5087 Assert(afterTriggers.maxquerydepth == 0);
5088 Assert(afterTriggers.event_cxt == NULL);
5089 Assert(afterTriggers.events.head == NULL);
5090 Assert(afterTriggers.trans_stack == NULL);
5091 Assert(afterTriggers.maxtransdepth == 0);
5092}
CommandId
uint32 CommandId
Definition: c.h:676
Assert
Assert(PointerIsAligned(start, uint64))
AfterTriggerEventList::head
AfterTriggerEventChunk * head
Definition: trigger.c:3775
AfterTriggersData::state
SetConstraintState state
Definition: trigger.c:3882
AfterTriggersData::query_stack
AfterTriggersQueryData * query_stack
Definition: trigger.c:3887
AfterTriggersData::event_cxt
MemoryContext event_cxt
Definition: trigger.c:3884

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

Referenced by StartTransaction().

◆ AfterTriggerEndQuery()

void AfterTriggerEndQuery ( EState *  estate)

Definition at line 5124 of file trigger.c.

5125{
5126 AfterTriggersQueryData *qs;
5127
5128 /* Must be inside a query, too */
5129 Assert(afterTriggers.query_depth >= 0);
5130
5131 /*
5132 * If we never even got as far as initializing the event stack, there
5133 * certainly won't be any events, so exit quickly.
5134 */
5135 if (afterTriggers.query_depth >= afterTriggers.maxquerydepth)
5136 {
5137 afterTriggers.query_depth--;
5138 return;
5139 }
5140
5141 /*
5142 * Process all immediate-mode triggers queued by the query, and move the
5143 * deferred ones to the main list of deferred events.
5144 *
5145 * Notice that we decide which ones will be fired, and put the deferred
5146 * ones on the main list, before anything is actually fired. This ensures
5147 * reasonably sane behavior if a trigger function does SET CONSTRAINTS ...
5148 * IMMEDIATE: all events we have decided to defer will be available for it
5149 * to fire.
5150 *
5151 * We loop in case a trigger queues more events at the same query level.
5152 * Ordinary trigger functions, including all PL/pgSQL trigger functions,
5153 * will instead fire any triggers in a dedicated query level. Foreign key
5154 * enforcement triggers do add to the current query level, thanks to their
5155 * passing fire_triggers = false to SPI_execute_snapshot(). Other
5156 * C-language triggers might do likewise.
5157 *
5158 * If we find no firable events, we don't have to increment
5159 * firing_counter.
5160 */
5161 qs = &afterTriggers.query_stack[afterTriggers.query_depth];
5162
5163 for (;;)
5164 {
5165 if (afterTriggerMarkEvents(&qs->events, &afterTriggers.events, true))
5166 {
5167 CommandId firing_id = afterTriggers.firing_counter++;
5168 AfterTriggerEventChunk *oldtail = qs->events.tail;
5169
5170 if (afterTriggerInvokeEvents(&qs->events, firing_id, estate, false))
5171 break; /* all fired */
5172
5173 /*
5174 * Firing a trigger could result in query_stack being repalloc'd,
5175 * so we must recalculate qs after each afterTriggerInvokeEvents
5176 * call. Furthermore, it's unsafe to pass delete_ok = true here,
5177 * because that could cause afterTriggerInvokeEvents to try to
5178 * access qs->events after the stack has been repalloc'd.
5179 */
5180 qs = &afterTriggers.query_stack[afterTriggers.query_depth];
5181
5182 /*
5183 * We'll need to scan the events list again. To reduce the cost
5184 * of doing so, get rid of completely-fired chunks. We know that
5185 * all events were marked IN_PROGRESS or DONE at the conclusion of
5186 * afterTriggerMarkEvents, so any still-interesting events must
5187 * have been added after that, and so must be in the chunk that
5188 * was then the tail chunk, or in later chunks. So, zap all
5189 * chunks before oldtail. This is approximately the same set of
5190 * events we would have gotten rid of by passing delete_ok = true.
5191 */
5192 Assert(oldtail != NULL);
5193 while (qs->events.head != oldtail)
5194 afterTriggerDeleteHeadEventChunk(qs);
5195 }
5196 else
5197 break;
5198 }
5199
5200 /* Release query-level-local storage, including tuplestores if any */
5201 AfterTriggerFreeQuery(&afterTriggers.query_stack[afterTriggers.query_depth]);
5202
5203 afterTriggers.query_depth--;
5204}
AfterTriggerEventList::tail
AfterTriggerEventChunk * tail
Definition: trigger.c:3776
AfterTriggersQueryData::events
AfterTriggerEventList events
Definition: trigger.c:3898
afterTriggerDeleteHeadEventChunk
static void afterTriggerDeleteHeadEventChunk(AfterTriggersQueryData *qs)
Definition: trigger.c:4275
AfterTriggerFreeQuery
static void AfterTriggerFreeQuery(AfterTriggersQueryData *qs)
Definition: trigger.c:5215
afterTriggerMarkEvents
static bool afterTriggerMarkEvents(AfterTriggerEventList *events, AfterTriggerEventList *move_list, bool immediate_only)
Definition: trigger.c:4629
afterTriggerInvokeEvents
static bool afterTriggerInvokeEvents(AfterTriggerEventList *events, CommandId firing_id, EState *estate, bool delete_ok)
Definition: trigger.c:4713

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

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

◆ AfterTriggerEndSubXact()

void AfterTriggerEndSubXact ( bool  isCommit)

Definition at line 5435 of file trigger.c.

5436{
5437 int my_level = GetCurrentTransactionNestLevel();
5438 SetConstraintState state;
5439 AfterTriggerEvent event;
5440 AfterTriggerEventChunk *chunk;
5441 CommandId subxact_firing_id;
5442
5443 /*
5444 * Pop the prior state if needed.
5445 */
5446 if (isCommit)
5447 {
5448 Assert(my_level < afterTriggers.maxtransdepth);
5449 /* If we saved a prior state, we don't need it anymore */
5450 state = afterTriggers.trans_stack[my_level].state;
5451 if (state != NULL)
5452 pfree(state);
5453 /* this avoids double pfree if error later: */
5454 afterTriggers.trans_stack[my_level].state = NULL;
5455 Assert(afterTriggers.query_depth ==
5456 afterTriggers.trans_stack[my_level].query_depth);
5457 }
5458 else
5459 {
5460 /*
5461 * Aborting. It is possible subxact start failed before calling
5462 * AfterTriggerBeginSubXact, in which case we mustn't risk touching
5463 * trans_stack levels that aren't there.
5464 */
5465 if (my_level >= afterTriggers.maxtransdepth)
5466 return;
5467
5468 /*
5469 * Release query-level storage for queries being aborted, and restore
5470 * query_depth to its pre-subxact value. This assumes that a
5471 * subtransaction will not add events to query levels started in a
5472 * earlier transaction state.
5473 */
5474 while (afterTriggers.query_depth > afterTriggers.trans_stack[my_level].query_depth)
5475 {
5476 if (afterTriggers.query_depth < afterTriggers.maxquerydepth)
5477 AfterTriggerFreeQuery(&afterTriggers.query_stack[afterTriggers.query_depth]);
5478 afterTriggers.query_depth--;
5479 }
5480 Assert(afterTriggers.query_depth ==
5481 afterTriggers.trans_stack[my_level].query_depth);
5482
5483 /*
5484 * Restore the global deferred-event list to its former length,
5485 * discarding any events queued by the subxact.
5486 */
5487 afterTriggerRestoreEventList(&afterTriggers.events,
5488 &afterTriggers.trans_stack[my_level].events);
5489
5490 /*
5491 * Restore the trigger state. If the saved state is NULL, then this
5492 * subxact didn't save it, so it doesn't need restoring.
5493 */
5494 state = afterTriggers.trans_stack[my_level].state;
5495 if (state != NULL)
5496 {
5497 pfree(afterTriggers.state);
5498 afterTriggers.state = state;
5499 }
5500 /* this avoids double pfree if error later: */
5501 afterTriggers.trans_stack[my_level].state = NULL;
5502
5503 /*
5504 * Scan for any remaining deferred events that were marked DONE or IN
5505 * PROGRESS by this subxact or a child, and un-mark them. We can
5506 * recognize such events because they have a firing ID greater than or
5507 * equal to the firing_counter value we saved at subtransaction start.
5508 * (This essentially assumes that the current subxact includes all
5509 * subxacts started after it.)
5510 */
5511 subxact_firing_id = afterTriggers.trans_stack[my_level].firing_counter;
5512 for_each_event_chunk(event, chunk, afterTriggers.events)
5513 {
5514 AfterTriggerShared evtshared = GetTriggerSharedData(event);
5515
5516 if (event->ate_flags &
5517 (AFTER_TRIGGER_DONE | AFTER_TRIGGER_IN_PROGRESS))
5518 {
5519 if (evtshared->ats_firing_id >= subxact_firing_id)
5520 event->ate_flags &=
5521 ~(AFTER_TRIGGER_DONE | AFTER_TRIGGER_IN_PROGRESS);
5522 }
5523 }
5524 }
5525}
pfree
void pfree(void *pointer)
Definition: mcxt.c:1594
AfterTriggerEventData::ate_flags
TriggerFlags ate_flags
Definition: trigger.c:3708
AfterTriggerSharedData::ats_firing_id
CommandId ats_firing_id
Definition: trigger.c:3699
state
Definition: regguts.h:323
AFTER_TRIGGER_IN_PROGRESS
#define AFTER_TRIGGER_IN_PROGRESS
Definition: trigger.c:3683
GetTriggerSharedData
#define GetTriggerSharedData(evt)
Definition: trigger.c:3751
afterTriggerRestoreEventList
static void afterTriggerRestoreEventList(AfterTriggerEventList *events, const AfterTriggerEventList *old_events)
Definition: trigger.c:4235
AFTER_TRIGGER_DONE
#define AFTER_TRIGGER_DONE
Definition: trigger.c:3682
for_each_event_chunk
#define for_each_event_chunk(eptr, cptr, evtlist)
Definition: trigger.c:3788

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AfterTriggerEndXact()

void AfterTriggerEndXact ( bool  isCommit)

Definition at line 5339 of file trigger.c.

5340{
5341 /*
5342 * Forget the pending-events list.
5343 *
5344 * Since all the info is in TopTransactionContext or children thereof, we
5345 * don't really need to do anything to reclaim memory. However, the
5346 * pending-events list could be large, and so it's useful to discard it as
5347 * soon as possible --- especially if we are aborting because we ran out
5348 * of memory for the list!
5349 */
5350 if (afterTriggers.event_cxt)
5351 {
5352 MemoryContextDelete(afterTriggers.event_cxt);
5353 afterTriggers.event_cxt = NULL;
5354 afterTriggers.events.head = NULL;
5355 afterTriggers.events.tail = NULL;
5356 afterTriggers.events.tailfree = NULL;
5357 }
5358
5359 /*
5360 * Forget any subtransaction state as well. Since this can't be very
5361 * large, we let the eventual reset of TopTransactionContext free the
5362 * memory instead of doing it here.
5363 */
5364 afterTriggers.trans_stack = NULL;
5365 afterTriggers.maxtransdepth = 0;
5366
5367
5368 /*
5369 * Forget the query stack and constraint-related state information. As
5370 * with the subtransaction state information, we don't bother freeing the
5371 * memory here.
5372 */
5373 afterTriggers.query_stack = NULL;
5374 afterTriggers.maxquerydepth = 0;
5375 afterTriggers.state = NULL;
5376
5377 /* No more afterTriggers manipulation until next transaction starts. */
5378 afterTriggers.query_depth = -1;
5379}
MemoryContextDelete
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:469

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

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

◆ AfterTriggerFireDeferred()

void AfterTriggerFireDeferred ( void  )

Definition at line 5283 of file trigger.c.

5284{
5285 AfterTriggerEventList *events;
5286 bool snap_pushed = false;
5287
5288 /* Must not be inside a query */
5289 Assert(afterTriggers.query_depth == -1);
5290
5291 /*
5292 * If there are any triggers to fire, make sure we have set a snapshot for
5293 * them to use. (Since PortalRunUtility doesn't set a snap for COMMIT, we
5294 * can't assume ActiveSnapshot is valid on entry.)
5295 */
5296 events = &afterTriggers.events;
5297 if (events->head != NULL)
5298 {
5299 PushActiveSnapshot(GetTransactionSnapshot());
5300 snap_pushed = true;
5301 }
5302
5303 /*
5304 * Run all the remaining triggers. Loop until they are all gone, in case
5305 * some trigger queues more for us to do.
5306 */
5307 while (afterTriggerMarkEvents(events, NULL, false))
5308 {
5309 CommandId firing_id = afterTriggers.firing_counter++;
5310
5311 if (afterTriggerInvokeEvents(events, firing_id, NULL, true))
5312 break; /* all fired */
5313 }
5314
5315 /*
5316 * We don't bother freeing the event list, since it will go away anyway
5317 * (and more efficiently than via pfree) in AfterTriggerEndXact.
5318 */
5319
5320 if (snap_pushed)
5321 PopActiveSnapshot();
5322}
GetTransactionSnapshot
Snapshot GetTransactionSnapshot(void)
Definition: snapmgr.c:271
PushActiveSnapshot
void PushActiveSnapshot(Snapshot snapshot)
Definition: snapmgr.c:680
PopActiveSnapshot
void PopActiveSnapshot(void)
Definition: snapmgr.c:773

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

Referenced by CommitTransaction(), and PrepareTransaction().

◆ AfterTriggerPendingOnRel()

bool AfterTriggerPendingOnRel ( Oid  relid)

Definition at line 6060 of file trigger.c.

6061{
6062 AfterTriggerEvent event;
6063 AfterTriggerEventChunk *chunk;
6064 int depth;
6065
6066 /* Scan queued events */
6067 for_each_event_chunk(event, chunk, afterTriggers.events)
6068 {
6069 AfterTriggerShared evtshared = GetTriggerSharedData(event);
6070
6071 /*
6072 * We can ignore completed events. (Even if a DONE flag is rolled
6073 * back by subxact abort, it's OK because the effects of the TRUNCATE
6074 * or whatever must get rolled back too.)
6075 */
6076 if (event->ate_flags & AFTER_TRIGGER_DONE)
6077 continue;
6078
6079 if (evtshared->ats_relid == relid)
6080 return true;
6081 }
6082
6083 /*
6084 * Also scan events queued by incomplete queries. This could only matter
6085 * if TRUNCATE/etc is executed by a function or trigger within an updating
6086 * query on the same relation, which is pretty perverse, but let's check.
6087 */
6088 for (depth = 0; depth <= afterTriggers.query_depth && depth < afterTriggers.maxquerydepth; depth++)
6089 {
6090 for_each_event_chunk(event, chunk, afterTriggers.query_stack[depth].events)
6091 {
6092 AfterTriggerShared evtshared = GetTriggerSharedData(event);
6093
6094 if (event->ate_flags & AFTER_TRIGGER_DONE)
6095 continue;
6096
6097 if (evtshared->ats_relid == relid)
6098 return true;
6099 }
6100 }
6101
6102 return false;
6103}

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

Referenced by CheckTableNotInUse().

◆ AfterTriggerSetState()

void AfterTriggerSetState ( ConstraintsSetStmt *  stmt)

Definition at line 5745 of file trigger.c.

5746{
5747 int my_level = GetCurrentTransactionNestLevel();
5748
5749 /* If we haven't already done so, initialize our state. */
5750 if (afterTriggers.state == NULL)
5751 afterTriggers.state = SetConstraintStateCreate(8);
5752
5753 /*
5754 * If in a subtransaction, and we didn't save the current state already,
5755 * save it so it can be restored if the subtransaction aborts.
5756 */
5757 if (my_level > 1 &&
5758 afterTriggers.trans_stack[my_level].state == NULL)
5759 {
5760 afterTriggers.trans_stack[my_level].state =
5761 SetConstraintStateCopy(afterTriggers.state);
5762 }
5763
5764 /*
5765 * Handle SET CONSTRAINTS ALL ...
5766 */
5767 if (stmt->constraints == NIL)
5768 {
5769 /*
5770 * Forget any previous SET CONSTRAINTS commands in this transaction.
5771 */
5772 afterTriggers.state->numstates = 0;
5773
5774 /*
5775 * Set the per-transaction ALL state to known.
5776 */
5777 afterTriggers.state->all_isset = true;
5778 afterTriggers.state->all_isdeferred = stmt->deferred;
5779 }
5780 else
5781 {
5782 Relation conrel;
5783 Relation tgrel;
5784 List *conoidlist = NIL;
5785 List *tgoidlist = NIL;
5786 ListCell *lc;
5787
5788 /*
5789 * Handle SET CONSTRAINTS constraint-name [, ...]
5790 *
5791 * First, identify all the named constraints and make a list of their
5792 * OIDs. Since, unlike the SQL spec, we allow multiple constraints of
5793 * the same name within a schema, the specifications are not
5794 * necessarily unique. Our strategy is to target all matching
5795 * constraints within the first search-path schema that has any
5796 * matches, but disregard matches in schemas beyond the first match.
5797 * (This is a bit odd but it's the historical behavior.)
5798 *
5799 * A constraint in a partitioned table may have corresponding
5800 * constraints in the partitions. Grab those too.
5801 */
5802 conrel = table_open(ConstraintRelationId, AccessShareLock);
5803
5804 foreach(lc, stmt->constraints)
5805 {
5806 RangeVar *constraint = lfirst(lc);
5807 bool found;
5808 List *namespacelist;
5809 ListCell *nslc;
5810
5811 if (constraint->catalogname)
5812 {
5813 if (strcmp(constraint->catalogname, get_database_name(MyDatabaseId)) != 0)
5814 ereport(ERROR,
5815 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
5816 errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
5817 constraint->catalogname, constraint->schemaname,
5818 constraint->relname)));
5819 }
5820
5821 /*
5822 * If we're given the schema name with the constraint, look only
5823 * in that schema. If given a bare constraint name, use the
5824 * search path to find the first matching constraint.
5825 */
5826 if (constraint->schemaname)
5827 {
5828 Oid namespaceId = LookupExplicitNamespace(constraint->schemaname,
5829 false);
5830
5831 namespacelist = list_make1_oid(namespaceId);
5832 }
5833 else
5834 {
5835 namespacelist = fetch_search_path(true);
5836 }
5837
5838 found = false;
5839 foreach(nslc, namespacelist)
5840 {
5841 Oid namespaceId = lfirst_oid(nslc);
5842 SysScanDesc conscan;
5843 ScanKeyData skey[2];
5844 HeapTuple tup;
5845
5846 ScanKeyInit(&skey[0],
5847 Anum_pg_constraint_conname,
5848 BTEqualStrategyNumber, F_NAMEEQ,
5849 CStringGetDatum(constraint->relname));
5850 ScanKeyInit(&skey[1],
5851 Anum_pg_constraint_connamespace,
5852 BTEqualStrategyNumber, F_OIDEQ,
5853 ObjectIdGetDatum(namespaceId));
5854
5855 conscan = systable_beginscan(conrel, ConstraintNameNspIndexId,
5856 true, NULL, 2, skey);
5857
5858 while (HeapTupleIsValid(tup = systable_getnext(conscan)))
5859 {
5860 Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tup);
5861
5862 if (con->condeferrable)
5863 conoidlist = lappend_oid(conoidlist, con->oid);
5864 else if (stmt->deferred)
5865 ereport(ERROR,
5866 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
5867 errmsg("constraint \"%s\" is not deferrable",
5868 constraint->relname)));
5869 found = true;
5870 }
5871
5872 systable_endscan(conscan);
5873
5874 /*
5875 * Once we've found a matching constraint we do not search
5876 * later parts of the search path.
5877 */
5878 if (found)
5879 break;
5880 }
5881
5882 list_free(namespacelist);
5883
5884 /*
5885 * Not found ?
5886 */
5887 if (!found)
5888 ereport(ERROR,
5889 (errcode(ERRCODE_UNDEFINED_OBJECT),
5890 errmsg("constraint \"%s\" does not exist",
5891 constraint->relname)));
5892 }
5893
5894 /*
5895 * Scan for any possible descendants of the constraints. We append
5896 * whatever we find to the same list that we're scanning; this has the
5897 * effect that we create new scans for those, too, so if there are
5898 * further descendents, we'll also catch them.
5899 */
5900 foreach(lc, conoidlist)
5901 {
5902 Oid parent = lfirst_oid(lc);
5903 ScanKeyData key;
5904 SysScanDesc scan;
5905 HeapTuple tuple;
5906
5907 ScanKeyInit(&key,
5908 Anum_pg_constraint_conparentid,
5909 BTEqualStrategyNumber, F_OIDEQ,
5910 ObjectIdGetDatum(parent));
5911
5912 scan = systable_beginscan(conrel, ConstraintParentIndexId, true, NULL, 1, &key);
5913
5914 while (HeapTupleIsValid(tuple = systable_getnext(scan)))
5915 {
5916 Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tuple);
5917
5918 conoidlist = lappend_oid(conoidlist, con->oid);
5919 }
5920
5921 systable_endscan(scan);
5922 }
5923
5924 table_close(conrel, AccessShareLock);
5925
5926 /*
5927 * Now, locate the trigger(s) implementing each of these constraints,
5928 * and make a list of their OIDs.
5929 */
5930 tgrel = table_open(TriggerRelationId, AccessShareLock);
5931
5932 foreach(lc, conoidlist)
5933 {
5934 Oid conoid = lfirst_oid(lc);
5935 ScanKeyData skey;
5936 SysScanDesc tgscan;
5937 HeapTuple htup;
5938
5939 ScanKeyInit(&skey,
5940 Anum_pg_trigger_tgconstraint,
5941 BTEqualStrategyNumber, F_OIDEQ,
5942 ObjectIdGetDatum(conoid));
5943
5944 tgscan = systable_beginscan(tgrel, TriggerConstraintIndexId, true,
5945 NULL, 1, &skey);
5946
5947 while (HeapTupleIsValid(htup = systable_getnext(tgscan)))
5948 {
5949 Form_pg_trigger pg_trigger = (Form_pg_trigger) GETSTRUCT(htup);
5950
5951 /*
5952 * Silently skip triggers that are marked as non-deferrable in
5953 * pg_trigger. This is not an error condition, since a
5954 * deferrable RI constraint may have some non-deferrable
5955 * actions.
5956 */
5957 if (pg_trigger->tgdeferrable)
5958 tgoidlist = lappend_oid(tgoidlist, pg_trigger->oid);
5959 }
5960
5961 systable_endscan(tgscan);
5962 }
5963
5964 table_close(tgrel, AccessShareLock);
5965
5966 /*
5967 * Now we can set the trigger states of individual triggers for this
5968 * xact.
5969 */
5970 foreach(lc, tgoidlist)
5971 {
5972 Oid tgoid = lfirst_oid(lc);
5973 SetConstraintState state = afterTriggers.state;
5974 bool found = false;
5975 int i;
5976
5977 for (i = 0; i < state->numstates; i++)
5978 {
5979 if (state->trigstates[i].sct_tgoid == tgoid)
5980 {
5981 state->trigstates[i].sct_tgisdeferred = stmt->deferred;
5982 found = true;
5983 break;
5984 }
5985 }
5986 if (!found)
5987 {
5988 afterTriggers.state =
5989 SetConstraintStateAddItem(state, tgoid, stmt->deferred);
5990 }
5991 }
5992 }
5993
5994 /*
5995 * SQL99 requires that when a constraint is set to IMMEDIATE, any deferred
5996 * checks against that constraint must be made when the SET CONSTRAINTS
5997 * command is executed -- i.e. the effects of the SET CONSTRAINTS command
5998 * apply retroactively. We've updated the constraints state, so scan the
5999 * list of previously deferred events to fire any that have now become
6000 * immediate.
6001 *
6002 * Obviously, if this was SET ... DEFERRED then it can't have converted
6003 * any unfired events to immediate, so we need do nothing in that case.
6004 */
6005 if (!stmt->deferred)
6006 {
6007 AfterTriggerEventList *events = &afterTriggers.events;
6008 bool snapshot_set = false;
6009
6010 while (afterTriggerMarkEvents(events, NULL, true))
6011 {
6012 CommandId firing_id = afterTriggers.firing_counter++;
6013
6014 /*
6015 * Make sure a snapshot has been established in case trigger
6016 * functions need one. Note that we avoid setting a snapshot if
6017 * we don't find at least one trigger that has to be fired now.
6018 * This is so that BEGIN; SET CONSTRAINTS ...; SET TRANSACTION
6019 * ISOLATION LEVEL SERIALIZABLE; ... works properly. (If we are
6020 * at the start of a transaction it's not possible for any trigger
6021 * events to be queued yet.)
6022 */
6023 if (!snapshot_set)
6024 {
6025 PushActiveSnapshot(GetTransactionSnapshot());
6026 snapshot_set = true;
6027 }
6028
6029 /*
6030 * We can delete fired events if we are at top transaction level,
6031 * but we'd better not if inside a subtransaction, since the
6032 * subtransaction could later get rolled back.
6033 */
6034 if (afterTriggerInvokeEvents(events, firing_id, NULL,
6035 !IsSubTransaction()))
6036 break; /* all fired */
6037 }
6038
6039 if (snapshot_set)
6040 PopActiveSnapshot();
6041 }
6042}
errcode
int errcode(int sqlerrcode)
Definition: elog.c:863
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:1080
ERROR
#define ERROR
Definition: elog.h:39
ereport
#define ereport(elevel,...)
Definition: elog.h:150
systable_endscan
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:603
systable_getnext
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:514
systable_beginscan
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:388
MyDatabaseId
Oid MyDatabaseId
Definition: globals.c:94
HeapTupleIsValid
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
GETSTRUCT
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
stmt
#define stmt
Definition: indent_codes.h:59
i
int i
Definition: isn.c:77
lappend_oid
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
list_free
void list_free(List *list)
Definition: list.c:1546
AccessShareLock
#define AccessShareLock
Definition: lockdefs.h:36
get_database_name
char * get_database_name(Oid dbid)
Definition: lsyscache.c:1259
LookupExplicitNamespace
Oid LookupExplicitNamespace(const char *nspname, bool missing_ok)
Definition: namespace.c:3455
fetch_search_path
List * fetch_search_path(bool includeImplicit)
Definition: namespace.c:4889
Form_pg_constraint
FormData_pg_constraint * Form_pg_constraint
Definition: pg_constraint.h:175
lfirst
#define lfirst(lc)
Definition: pg_list.h:172
NIL
#define NIL
Definition: pg_list.h:68
list_make1_oid
#define list_make1_oid(x1)
Definition: pg_list.h:242
lfirst_oid
#define lfirst_oid(lc)
Definition: pg_list.h:174
Form_pg_trigger
FormData_pg_trigger * Form_pg_trigger
Definition: pg_trigger.h:80
ObjectIdGetDatum
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
CStringGetDatum
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:360
Oid
unsigned int Oid
Definition: postgres_ext.h:32
ScanKeyInit
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
BTEqualStrategyNumber
#define BTEqualStrategyNumber
Definition: stratnum.h:31
List
Definition: pg_list.h:54
RangeVar::relname
char * relname
Definition: primnodes.h:83
RangeVar::catalogname
char * catalogname
Definition: primnodes.h:77
RangeVar::schemaname
char * schemaname
Definition: primnodes.h:80
table_close
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
table_open
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
SetConstraintStateCopy
static SetConstraintState SetConstraintStateCopy(SetConstraintState origstate)
Definition: trigger.c:5695
SetConstraintStateAddItem
static SetConstraintState SetConstraintStateAddItem(SetConstraintState state, Oid tgoid, bool tgisdeferred)
Definition: trigger.c:5715
SetConstraintStateCreate
static SetConstraintState SetConstraintStateCreate(int numalloc)
Definition: trigger.c:5670
IsSubTransaction
bool IsSubTransaction(void)
Definition: xact.c:5062

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

Referenced by standard_ProcessUtility().

◆ CopyTriggerDesc()

TriggerDesc * CopyTriggerDesc ( TriggerDesc *  trigdesc)

Definition at line 2090 of file trigger.c.

2091{
2092 TriggerDesc *newdesc;
2093 Trigger *trigger;
2094 int i;
2095
2096 if (trigdesc == NULL || trigdesc->numtriggers <= 0)
2097 return NULL;
2098
2099 newdesc = (TriggerDesc *) palloc(sizeof(TriggerDesc));
2100 memcpy(newdesc, trigdesc, sizeof(TriggerDesc));
2101
2102 trigger = (Trigger *) palloc(trigdesc->numtriggers * sizeof(Trigger));
2103 memcpy(trigger, trigdesc->triggers,
2104 trigdesc->numtriggers * sizeof(Trigger));
2105 newdesc->triggers = trigger;
2106
2107 for (i = 0; i < trigdesc->numtriggers; i++)
2108 {
2109 trigger->tgname = pstrdup(trigger->tgname);
2110 if (trigger->tgnattr > 0)
2111 {
2112 int16 *newattr;
2113
2114 newattr = (int16 *) palloc(trigger->tgnattr * sizeof(int16));
2115 memcpy(newattr, trigger->tgattr,
2116 trigger->tgnattr * sizeof(int16));
2117 trigger->tgattr = newattr;
2118 }
2119 if (trigger->tgnargs > 0)
2120 {
2121 char **newargs;
2122 int16 j;
2123
2124 newargs = (char **) palloc(trigger->tgnargs * sizeof(char *));
2125 for (j = 0; j < trigger->tgnargs; j++)
2126 newargs[j] = pstrdup(trigger->tgargs[j]);
2127 trigger->tgargs = newargs;
2128 }
2129 if (trigger->tgqual)
2130 trigger->tgqual = pstrdup(trigger->tgqual);
2131 if (trigger->tgoldtable)
2132 trigger->tgoldtable = pstrdup(trigger->tgoldtable);
2133 if (trigger->tgnewtable)
2134 trigger->tgnewtable = pstrdup(trigger->tgnewtable);
2135 trigger++;
2136 }
2137
2138 return newdesc;
2139}
int16
int16_t int16
Definition: c.h:538
j
int j
Definition: isn.c:78
pstrdup
char * pstrdup(const char *in)
Definition: mcxt.c:1759
palloc
void * palloc(Size size)
Definition: mcxt.c:1365
TriggerDesc::numtriggers
int numtriggers
Definition: reltrigger.h:50
TriggerDesc::triggers
Trigger * triggers
Definition: reltrigger.h:49
Trigger::tgoldtable
char * tgoldtable
Definition: reltrigger.h:43
Trigger::tgnewtable
char * tgnewtable
Definition: reltrigger.h:44
Trigger::tgname
char * tgname
Definition: reltrigger.h:27
Trigger::tgnargs
int16 tgnargs
Definition: reltrigger.h:38
Trigger::tgqual
char * tgqual
Definition: reltrigger.h:42
Trigger::tgnattr
int16 tgnattr
Definition: reltrigger.h:39
Trigger::tgargs
char ** tgargs
Definition: reltrigger.h:41
Trigger::tgattr
int16 * tgattr
Definition: reltrigger.h:40

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

Referenced by InitResultRelInfo(), and RelationBuildTriggers().

◆ CreateTrigger()

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

Definition at line 160 of file trigger.c.

164{
165 return
166 CreateTriggerFiringOn(stmt, queryString, relOid, refRelOid,
167 constraintOid, indexOid, funcoid,
168 parentTriggerOid, whenClause, isInternal,
169 in_partition, TRIGGER_FIRES_ON_ORIGIN);
170}
CreateTriggerFiringOn
ObjectAddress CreateTriggerFiringOn(CreateTrigStmt *stmt, const char *queryString, Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid funcoid, Oid parentTriggerOid, Node *whenClause, bool isInternal, bool in_partition, char trigger_fires_when)
Definition: trigger.c:177
TRIGGER_FIRES_ON_ORIGIN
#define TRIGGER_FIRES_ON_ORIGIN
Definition: trigger.h:149

References CreateTriggerFiringOn(), stmt, and TRIGGER_FIRES_ON_ORIGIN.

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

◆ CreateTriggerFiringOn()

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

Definition at line 177 of file trigger.c.

182{
183 int16 tgtype;
184 int ncolumns;
185 int16 *columns;
186 int2vector *tgattr;
187 List *whenRtable;
188 char *qual;
189 Datum values[Natts_pg_trigger];
190 bool nulls[Natts_pg_trigger];
191 Relation rel;
192 AclResult aclresult;
193 Relation tgrel;
194 Relation pgrel;
195 HeapTuple tuple = NULL;
196 Oid funcrettype;
197 Oid trigoid = InvalidOid;
198 char internaltrigname[NAMEDATALEN];
199 char *trigname;
200 Oid constrrelid = InvalidOid;
201 ObjectAddress myself,
202 referenced;
203 char *oldtablename = NULL;
204 char *newtablename = NULL;
205 bool partition_recurse;
206 bool trigger_exists = false;
207 Oid existing_constraint_oid = InvalidOid;
208 bool existing_isInternal = false;
209 bool existing_isClone = false;
210
211 if (OidIsValid(relOid))
212 rel = table_open(relOid, ShareRowExclusiveLock);
213 else
214 rel = table_openrv(stmt->relation, ShareRowExclusiveLock);
215
216 /*
217 * Triggers must be on tables or views, and there are additional
218 * relation-type-specific restrictions.
219 */
220 if (rel->rd_rel->relkind == RELKIND_RELATION)
221 {
222 /* Tables can't have INSTEAD OF triggers */
223 if (stmt->timing != TRIGGER_TYPE_BEFORE &&
224 stmt->timing != TRIGGER_TYPE_AFTER)
225 ereport(ERROR,
226 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
227 errmsg("\"%s\" is a table",
228 RelationGetRelationName(rel)),
229 errdetail("Tables cannot have INSTEAD OF triggers.")));
230 }
231 else if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
232 {
233 /* Partitioned tables can't have INSTEAD OF triggers */
234 if (stmt->timing != TRIGGER_TYPE_BEFORE &&
235 stmt->timing != TRIGGER_TYPE_AFTER)
236 ereport(ERROR,
237 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
238 errmsg("\"%s\" is a table",
239 RelationGetRelationName(rel)),
240 errdetail("Tables cannot have INSTEAD OF triggers.")));
241
242 /*
243 * FOR EACH ROW triggers have further restrictions
244 */
245 if (stmt->row)
246 {
247 /*
248 * Disallow use of transition tables.
249 *
250 * Note that we have another restriction about transition tables
251 * in partitions; search for 'has_superclass' below for an
252 * explanation. The check here is just to protect from the fact
253 * that if we allowed it here, the creation would succeed for a
254 * partitioned table with no partitions, but would be blocked by
255 * the other restriction when the first partition was created,
256 * which is very unfriendly behavior.
257 */
258 if (stmt->transitionRels != NIL)
259 ereport(ERROR,
260 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
261 errmsg("\"%s\" is a partitioned table",
262 RelationGetRelationName(rel)),
263 errdetail("ROW triggers with transition tables are not supported on partitioned tables.")));
264 }
265 }
266 else if (rel->rd_rel->relkind == RELKIND_VIEW)
267 {
268 /*
269 * Views can have INSTEAD OF triggers (which we check below are
270 * row-level), or statement-level BEFORE/AFTER triggers.
271 */
272 if (stmt->timing != TRIGGER_TYPE_INSTEAD && stmt->row)
273 ereport(ERROR,
274 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
275 errmsg("\"%s\" is a view",
276 RelationGetRelationName(rel)),
277 errdetail("Views cannot have row-level BEFORE or AFTER triggers.")));
278 /* Disallow TRUNCATE triggers on VIEWs */
279 if (TRIGGER_FOR_TRUNCATE(stmt->events))
280 ereport(ERROR,
281 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
282 errmsg("\"%s\" is a view",
283 RelationGetRelationName(rel)),
284 errdetail("Views cannot have TRUNCATE triggers.")));
285 }
286 else if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
287 {
288 if (stmt->timing != TRIGGER_TYPE_BEFORE &&
289 stmt->timing != TRIGGER_TYPE_AFTER)
290 ereport(ERROR,
291 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
292 errmsg("\"%s\" is a foreign table",
293 RelationGetRelationName(rel)),
294 errdetail("Foreign tables cannot have INSTEAD OF triggers.")));
295
296 /*
297 * We disallow constraint triggers to protect the assumption that
298 * triggers on FKs can't be deferred. See notes with AfterTriggers
299 * data structures, below.
300 */
301 if (stmt->isconstraint)
302 ereport(ERROR,
303 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
304 errmsg("\"%s\" is a foreign table",
305 RelationGetRelationName(rel)),
306 errdetail("Foreign tables cannot have constraint triggers.")));
307 }
308 else
309 ereport(ERROR,
310 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
311 errmsg("relation \"%s\" cannot have triggers",
312 RelationGetRelationName(rel)),
313 errdetail_relkind_not_supported(rel->rd_rel->relkind)));
314
315 if (!allowSystemTableMods && IsSystemRelation(rel))
316 ereport(ERROR,
317 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
318 errmsg("permission denied: \"%s\" is a system catalog",
319 RelationGetRelationName(rel))));
320
321 if (stmt->isconstraint)
322 {
323 /*
324 * We must take a lock on the target relation to protect against
325 * concurrent drop. It's not clear that AccessShareLock is strong
326 * enough, but we certainly need at least that much... otherwise, we
327 * might end up creating a pg_constraint entry referencing a
328 * nonexistent table.
329 */
330 if (OidIsValid(refRelOid))
331 {
332 LockRelationOid(refRelOid, AccessShareLock);
333 constrrelid = refRelOid;
334 }
335 else if (stmt->constrrel != NULL)
336 constrrelid = RangeVarGetRelid(stmt->constrrel, AccessShareLock,
337 false);
338 }
339
340 /* permission checks */
341 if (!isInternal)
342 {
343 aclresult = pg_class_aclcheck(RelationGetRelid(rel), GetUserId(),
344 ACL_TRIGGER);
345 if (aclresult != ACLCHECK_OK)
346 aclcheck_error(aclresult, get_relkind_objtype(rel->rd_rel->relkind),
347 RelationGetRelationName(rel));
348
349 if (OidIsValid(constrrelid))
350 {
351 aclresult = pg_class_aclcheck(constrrelid, GetUserId(),
352 ACL_TRIGGER);
353 if (aclresult != ACLCHECK_OK)
354 aclcheck_error(aclresult, get_relkind_objtype(get_rel_relkind(constrrelid)),
355 get_rel_name(constrrelid));
356 }
357 }
358
359 /*
360 * When called on a partitioned table to create a FOR EACH ROW trigger
361 * that's not internal, we create one trigger for each partition, too.
362 *
363 * For that, we'd better hold lock on all of them ahead of time.
364 */
365 partition_recurse = !isInternal && stmt->row &&
366 rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE;
367 if (partition_recurse)
368 list_free(find_all_inheritors(RelationGetRelid(rel),
369 ShareRowExclusiveLock, NULL));
370
371 /* Compute tgtype */
372 TRIGGER_CLEAR_TYPE(tgtype);
373 if (stmt->row)
374 TRIGGER_SETT_ROW(tgtype);
375 tgtype |= stmt->timing;
376 tgtype |= stmt->events;
377
378 /* Disallow ROW-level TRUNCATE triggers */
379 if (TRIGGER_FOR_ROW(tgtype) && TRIGGER_FOR_TRUNCATE(tgtype))
380 ereport(ERROR,
381 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
382 errmsg("TRUNCATE FOR EACH ROW triggers are not supported")));
383
384 /* INSTEAD triggers must be row-level, and can't have WHEN or columns */
385 if (TRIGGER_FOR_INSTEAD(tgtype))
386 {
387 if (!TRIGGER_FOR_ROW(tgtype))
388 ereport(ERROR,
389 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
390 errmsg("INSTEAD OF triggers must be FOR EACH ROW")));
391 if (stmt->whenClause)
392 ereport(ERROR,
393 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
394 errmsg("INSTEAD OF triggers cannot have WHEN conditions")));
395 if (stmt->columns != NIL)
396 ereport(ERROR,
397 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
398 errmsg("INSTEAD OF triggers cannot have column lists")));
399 }
400
401 /*
402 * We don't yet support naming ROW transition variables, but the parser
403 * recognizes the syntax so we can give a nicer message here.
404 *
405 * Per standard, REFERENCING TABLE names are only allowed on AFTER
406 * triggers. Per standard, REFERENCING ROW names are not allowed with FOR
407 * EACH STATEMENT. Per standard, each OLD/NEW, ROW/TABLE permutation is
408 * only allowed once. Per standard, OLD may not be specified when
409 * creating a trigger only for INSERT, and NEW may not be specified when
410 * creating a trigger only for DELETE.
411 *
412 * Notice that the standard allows an AFTER ... FOR EACH ROW trigger to
413 * reference both ROW and TABLE transition data.
414 */
415 if (stmt->transitionRels != NIL)
416 {
417 List *varList = stmt->transitionRels;
418 ListCell *lc;
419
420 foreach(lc, varList)
421 {
422 TriggerTransition *tt = lfirst_node(TriggerTransition, lc);
423
424 if (!(tt->isTable))
425 ereport(ERROR,
426 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
427 errmsg("ROW variable naming in the REFERENCING clause is not supported"),
428 errhint("Use OLD TABLE or NEW TABLE for naming transition tables.")));
429
430 /*
431 * Because of the above test, we omit further ROW-related testing
432 * below. If we later allow naming OLD and NEW ROW variables,
433 * adjustments will be needed below.
434 */
435
436 if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
437 ereport(ERROR,
438 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
439 errmsg("\"%s\" is a foreign table",
440 RelationGetRelationName(rel)),
441 errdetail("Triggers on foreign tables cannot have transition tables.")));
442
443 if (rel->rd_rel->relkind == RELKIND_VIEW)
444 ereport(ERROR,
445 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
446 errmsg("\"%s\" is a view",
447 RelationGetRelationName(rel)),
448 errdetail("Triggers on views cannot have transition tables.")));
449
450 /*
451 * We currently don't allow row-level triggers with transition
452 * tables on partition or inheritance children. Such triggers
453 * would somehow need to see tuples converted to the format of the
454 * table they're attached to, and it's not clear which subset of
455 * tuples each child should see. See also the prohibitions in
456 * ATExecAttachPartition() and ATExecAddInherit().
457 */
458 if (TRIGGER_FOR_ROW(tgtype) && has_superclass(rel->rd_id))
459 {
460 /* Use appropriate error message. */
461 if (rel->rd_rel->relispartition)
462 ereport(ERROR,
463 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
464 errmsg("ROW triggers with transition tables are not supported on partitions")));
465 else
466 ereport(ERROR,
467 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
468 errmsg("ROW triggers with transition tables are not supported on inheritance children")));
469 }
470
471 if (stmt->timing != TRIGGER_TYPE_AFTER)
472 ereport(ERROR,
473 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
474 errmsg("transition table name can only be specified for an AFTER trigger")));
475
476 if (TRIGGER_FOR_TRUNCATE(tgtype))
477 ereport(ERROR,
478 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
479 errmsg("TRUNCATE triggers with transition tables are not supported")));
480
481 /*
482 * We currently don't allow multi-event triggers ("INSERT OR
483 * UPDATE") with transition tables, because it's not clear how to
484 * handle INSERT ... ON CONFLICT statements which can fire both
485 * INSERT and UPDATE triggers. We show the inserted tuples to
486 * INSERT triggers and the updated tuples to UPDATE triggers, but
487 * it's not yet clear what INSERT OR UPDATE trigger should see.
488 * This restriction could be lifted if we can decide on the right
489 * semantics in a later release.
490 */
491 if (((TRIGGER_FOR_INSERT(tgtype) ? 1 : 0) +
492 (TRIGGER_FOR_UPDATE(tgtype) ? 1 : 0) +
493 (TRIGGER_FOR_DELETE(tgtype) ? 1 : 0)) != 1)
494 ereport(ERROR,
495 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
496 errmsg("transition tables cannot be specified for triggers with more than one event")));
497
498 /*
499 * We currently don't allow column-specific triggers with
500 * transition tables. Per spec, that seems to require
501 * accumulating separate transition tables for each combination of
502 * columns, which is a lot of work for a rather marginal feature.
503 */
504 if (stmt->columns != NIL)
505 ereport(ERROR,
506 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
507 errmsg("transition tables cannot be specified for triggers with column lists")));
508
509 /*
510 * We disallow constraint triggers with transition tables, to
511 * protect the assumption that such triggers can't be deferred.
512 * See notes with AfterTriggers data structures, below.
513 *
514 * Currently this is enforced by the grammar, so just Assert here.
515 */
516 Assert(!stmt->isconstraint);
517
518 if (tt->isNew)
519 {
520 if (!(TRIGGER_FOR_INSERT(tgtype) ||
521 TRIGGER_FOR_UPDATE(tgtype)))
522 ereport(ERROR,
523 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
524 errmsg("NEW TABLE can only be specified for an INSERT or UPDATE trigger")));
525
526 if (newtablename != NULL)
527 ereport(ERROR,
528 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
529 errmsg("NEW TABLE cannot be specified multiple times")));
530
531 newtablename = tt->name;
532 }
533 else
534 {
535 if (!(TRIGGER_FOR_DELETE(tgtype) ||
536 TRIGGER_FOR_UPDATE(tgtype)))
537 ereport(ERROR,
538 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
539 errmsg("OLD TABLE can only be specified for a DELETE or UPDATE trigger")));
540
541 if (oldtablename != NULL)
542 ereport(ERROR,
543 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
544 errmsg("OLD TABLE cannot be specified multiple times")));
545
546 oldtablename = tt->name;
547 }
548 }
549
550 if (newtablename != NULL && oldtablename != NULL &&
551 strcmp(newtablename, oldtablename) == 0)
552 ereport(ERROR,
553 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
554 errmsg("OLD TABLE name and NEW TABLE name cannot be the same")));
555 }
556
557 /*
558 * Parse the WHEN clause, if any and we weren't passed an already
559 * transformed one.
560 *
561 * Note that as a side effect, we fill whenRtable when parsing. If we got
562 * an already parsed clause, this does not occur, which is what we want --
563 * no point in adding redundant dependencies below.
564 */
565 if (!whenClause && stmt->whenClause)
566 {
567 ParseState *pstate;
568 ParseNamespaceItem *nsitem;
569 List *varList;
570 ListCell *lc;
571
572 /* Set up a pstate to parse with */
573 pstate = make_parsestate(NULL);
574 pstate->p_sourcetext = queryString;
575
576 /*
577 * Set up nsitems for OLD and NEW references.
578 *
579 * 'OLD' must always have varno equal to 1 and 'NEW' equal to 2.
580 */
581 nsitem = addRangeTableEntryForRelation(pstate, rel,
582 AccessShareLock,
583 makeAlias("old", NIL),
584 false, false);
585 addNSItemToQuery(pstate, nsitem, false, true, true);
586 nsitem = addRangeTableEntryForRelation(pstate, rel,
587 AccessShareLock,
588 makeAlias("new", NIL),
589 false, false);
590 addNSItemToQuery(pstate, nsitem, false, true, true);
591
592 /* Transform expression. Copy to be sure we don't modify original */
593 whenClause = transformWhereClause(pstate,
594 copyObject(stmt->whenClause),
595 EXPR_KIND_TRIGGER_WHEN,
596 "WHEN");
597 /* we have to fix its collations too */
598 assign_expr_collations(pstate, whenClause);
599
600 /*
601 * Check for disallowed references to OLD/NEW.
602 *
603 * NB: pull_var_clause is okay here only because we don't allow
604 * subselects in WHEN clauses; it would fail to examine the contents
605 * of subselects.
606 */
607 varList = pull_var_clause(whenClause, 0);
608 foreach(lc, varList)
609 {
610 Var *var = (Var *) lfirst(lc);
611
612 switch (var->varno)
613 {
614 case PRS2_OLD_VARNO:
615 if (!TRIGGER_FOR_ROW(tgtype))
616 ereport(ERROR,
617 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
618 errmsg("statement trigger's WHEN condition cannot reference column values"),
619 parser_errposition(pstate, var->location)));
620 if (TRIGGER_FOR_INSERT(tgtype))
621 ereport(ERROR,
622 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
623 errmsg("INSERT trigger's WHEN condition cannot reference OLD values"),
624 parser_errposition(pstate, var->location)));
625 /* system columns are okay here */
626 break;
627 case PRS2_NEW_VARNO:
628 if (!TRIGGER_FOR_ROW(tgtype))
629 ereport(ERROR,
630 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
631 errmsg("statement trigger's WHEN condition cannot reference column values"),
632 parser_errposition(pstate, var->location)));
633 if (TRIGGER_FOR_DELETE(tgtype))
634 ereport(ERROR,
635 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
636 errmsg("DELETE trigger's WHEN condition cannot reference NEW values"),
637 parser_errposition(pstate, var->location)));
638 if (var->varattno < 0 && TRIGGER_FOR_BEFORE(tgtype))
639 ereport(ERROR,
640 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
641 errmsg("BEFORE trigger's WHEN condition cannot reference NEW system columns"),
642 parser_errposition(pstate, var->location)));
643 if (TRIGGER_FOR_BEFORE(tgtype) &&
644 var->varattno == 0 &&
645 RelationGetDescr(rel)->constr &&
646 (RelationGetDescr(rel)->constr->has_generated_stored ||
647 RelationGetDescr(rel)->constr->has_generated_virtual))
648 ereport(ERROR,
649 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
650 errmsg("BEFORE trigger's WHEN condition cannot reference NEW generated columns"),
651 errdetail("A whole-row reference is used and the table contains generated columns."),
652 parser_errposition(pstate, var->location)));
653 if (TRIGGER_FOR_BEFORE(tgtype) &&
654 var->varattno > 0 &&
655 TupleDescAttr(RelationGetDescr(rel), var->varattno - 1)->attgenerated)
656 ereport(ERROR,
657 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
658 errmsg("BEFORE trigger's WHEN condition cannot reference NEW generated columns"),
659 errdetail("Column \"%s\" is a generated column.",
660 NameStr(TupleDescAttr(RelationGetDescr(rel), var->varattno - 1)->attname)),
661 parser_errposition(pstate, var->location)));
662 break;
663 default:
664 /* can't happen without add_missing_from, so just elog */
665 elog(ERROR, "trigger WHEN condition cannot contain references to other relations");
666 break;
667 }
668 }
669
670 /* we'll need the rtable for recordDependencyOnExpr */
671 whenRtable = pstate->p_rtable;
672
673 qual = nodeToString(whenClause);
674
675 free_parsestate(pstate);
676 }
677 else if (!whenClause)
678 {
679 whenClause = NULL;
680 whenRtable = NIL;
681 qual = NULL;
682 }
683 else
684 {
685 qual = nodeToString(whenClause);
686 whenRtable = NIL;
687 }
688
689 /*
690 * Find and validate the trigger function.
691 */
692 if (!OidIsValid(funcoid))
693 funcoid = LookupFuncName(stmt->funcname, 0, NULL, false);
694 if (!isInternal)
695 {
696 aclresult = object_aclcheck(ProcedureRelationId, funcoid, GetUserId(), ACL_EXECUTE);
697 if (aclresult != ACLCHECK_OK)
698 aclcheck_error(aclresult, OBJECT_FUNCTION,
699 NameListToString(stmt->funcname));
700 }
701 funcrettype = get_func_rettype(funcoid);
702 if (funcrettype != TRIGGEROID)
703 ereport(ERROR,
704 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
705 errmsg("function %s must return type %s",
706 NameListToString(stmt->funcname), "trigger")));
707
708 /*
709 * Scan pg_trigger to see if there is already a trigger of the same name.
710 * Skip this for internally generated triggers, since we'll modify the
711 * name to be unique below.
712 *
713 * NOTE that this is cool only because we have ShareRowExclusiveLock on
714 * the relation, so the trigger set won't be changing underneath us.
715 */
716 tgrel = table_open(TriggerRelationId, RowExclusiveLock);
717 if (!isInternal)
718 {
719 ScanKeyData skeys[2];
720 SysScanDesc tgscan;
721
722 ScanKeyInit(&skeys[0],
723 Anum_pg_trigger_tgrelid,
724 BTEqualStrategyNumber, F_OIDEQ,
725 ObjectIdGetDatum(RelationGetRelid(rel)));
726
727 ScanKeyInit(&skeys[1],
728 Anum_pg_trigger_tgname,
729 BTEqualStrategyNumber, F_NAMEEQ,
730 CStringGetDatum(stmt->trigname));
731
732 tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
733 NULL, 2, skeys);
734
735 /* There should be at most one matching tuple */
736 if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
737 {
738 Form_pg_trigger oldtrigger = (Form_pg_trigger) GETSTRUCT(tuple);
739
740 trigoid = oldtrigger->oid;
741 existing_constraint_oid = oldtrigger->tgconstraint;
742 existing_isInternal = oldtrigger->tgisinternal;
743 existing_isClone = OidIsValid(oldtrigger->tgparentid);
744 trigger_exists = true;
745 /* copy the tuple to use in CatalogTupleUpdate() */
746 tuple = heap_copytuple(tuple);
747 }
748 systable_endscan(tgscan);
749 }
750
751 if (!trigger_exists)
752 {
753 /* Generate the OID for the new trigger. */
754 trigoid = GetNewOidWithIndex(tgrel, TriggerOidIndexId,
755 Anum_pg_trigger_oid);
756 }
757 else
758 {
759 /*
760 * If OR REPLACE was specified, we'll replace the old trigger;
761 * otherwise complain about the duplicate name.
762 */
763 if (!stmt->replace)
764 ereport(ERROR,
765 (errcode(ERRCODE_DUPLICATE_OBJECT),
766 errmsg("trigger \"%s\" for relation \"%s\" already exists",
767 stmt->trigname, RelationGetRelationName(rel))));
768
769 /*
770 * An internal trigger or a child trigger (isClone) cannot be replaced
771 * by a user-defined trigger. However, skip this test when
772 * in_partition, because then we're recursing from a partitioned table
773 * and the check was made at the parent level.
774 */
775 if ((existing_isInternal || existing_isClone) &&
776 !isInternal && !in_partition)
777 ereport(ERROR,
778 (errcode(ERRCODE_DUPLICATE_OBJECT),
779 errmsg("trigger \"%s\" for relation \"%s\" is an internal or a child trigger",
780 stmt->trigname, RelationGetRelationName(rel))));
781
782 /*
783 * It is not allowed to replace with a constraint trigger; gram.y
784 * should have enforced this already.
785 */
786 Assert(!stmt->isconstraint);
787
788 /*
789 * It is not allowed to replace an existing constraint trigger,
790 * either. (The reason for these restrictions is partly that it seems
791 * difficult to deal with pending trigger events in such cases, and
792 * partly that the command might imply changing the constraint's
793 * properties as well, which doesn't seem nice.)
794 */
795 if (OidIsValid(existing_constraint_oid))
796 ereport(ERROR,
797 (errcode(ERRCODE_DUPLICATE_OBJECT),
798 errmsg("trigger \"%s\" for relation \"%s\" is a constraint trigger",
799 stmt->trigname, RelationGetRelationName(rel))));
800 }
801
802 /*
803 * If it's a user-entered CREATE CONSTRAINT TRIGGER command, make a
804 * corresponding pg_constraint entry.
805 */
806 if (stmt->isconstraint && !OidIsValid(constraintOid))
807 {
808 /* Internal callers should have made their own constraints */
809 Assert(!isInternal);
810 constraintOid = CreateConstraintEntry(stmt->trigname,
811 RelationGetNamespace(rel),
812 CONSTRAINT_TRIGGER,
813 stmt->deferrable,
814 stmt->initdeferred,
815 true, /* Is Enforced */
816 true,
817 InvalidOid, /* no parent */
818 RelationGetRelid(rel),
819 NULL, /* no conkey */
820 0,
821 0,
822 InvalidOid, /* no domain */
823 InvalidOid, /* no index */
824 InvalidOid, /* no foreign key */
825 NULL,
826 NULL,
827 NULL,
828 NULL,
829 0,
830 ' ',
831 ' ',
832 NULL,
833 0,
834 ' ',
835 NULL, /* no exclusion */
836 NULL, /* no check constraint */
837 NULL,
838 true, /* islocal */
839 0, /* inhcount */
840 true, /* noinherit */
841 false, /* conperiod */
842 isInternal); /* is_internal */
843 }
844
845 /*
846 * If trigger is internally generated, modify the provided trigger name to
847 * ensure uniqueness by appending the trigger OID. (Callers will usually
848 * supply a simple constant trigger name in these cases.)
849 */
850 if (isInternal)
851 {
852 snprintf(internaltrigname, sizeof(internaltrigname),
853 "%s_%u", stmt->trigname, trigoid);
854 trigname = internaltrigname;
855 }
856 else
857 {
858 /* user-defined trigger; use the specified trigger name as-is */
859 trigname = stmt->trigname;
860 }
861
862 /*
863 * Build the new pg_trigger tuple.
864 */
865 memset(nulls, false, sizeof(nulls));
866
867 values[Anum_pg_trigger_oid - 1] = ObjectIdGetDatum(trigoid);
868 values[Anum_pg_trigger_tgrelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
869 values[Anum_pg_trigger_tgparentid - 1] = ObjectIdGetDatum(parentTriggerOid);
870 values[Anum_pg_trigger_tgname - 1] = DirectFunctionCall1(namein,
871 CStringGetDatum(trigname));
872 values[Anum_pg_trigger_tgfoid - 1] = ObjectIdGetDatum(funcoid);
873 values[Anum_pg_trigger_tgtype - 1] = Int16GetDatum(tgtype);
874 values[Anum_pg_trigger_tgenabled - 1] = CharGetDatum(trigger_fires_when);
875 values[Anum_pg_trigger_tgisinternal - 1] = BoolGetDatum(isInternal);
876 values[Anum_pg_trigger_tgconstrrelid - 1] = ObjectIdGetDatum(constrrelid);
877 values[Anum_pg_trigger_tgconstrindid - 1] = ObjectIdGetDatum(indexOid);
878 values[Anum_pg_trigger_tgconstraint - 1] = ObjectIdGetDatum(constraintOid);
879 values[Anum_pg_trigger_tgdeferrable - 1] = BoolGetDatum(stmt->deferrable);
880 values[Anum_pg_trigger_tginitdeferred - 1] = BoolGetDatum(stmt->initdeferred);
881
882 if (stmt->args)
883 {
884 ListCell *le;
885 char *args;
886 int16 nargs = list_length(stmt->args);
887 int len = 0;
888
889 foreach(le, stmt->args)
890 {
891 char *ar = strVal(lfirst(le));
892
893 len += strlen(ar) + 4;
894 for (; *ar; ar++)
895 {
896 if (*ar == '\\')
897 len++;
898 }
899 }
900 args = (char *) palloc(len + 1);
901 args[0] = '\0';
902 foreach(le, stmt->args)
903 {
904 char *s = strVal(lfirst(le));
905 char *d = args + strlen(args);
906
907 while (*s)
908 {
909 if (*s == '\\')
910 *d++ = '\\';
911 *d++ = *s++;
912 }
913 strcpy(d, "\\000");
914 }
915 values[Anum_pg_trigger_tgnargs - 1] = Int16GetDatum(nargs);
916 values[Anum_pg_trigger_tgargs - 1] = DirectFunctionCall1(byteain,
917 CStringGetDatum(args));
918 }
919 else
920 {
921 values[Anum_pg_trigger_tgnargs - 1] = Int16GetDatum(0);
922 values[Anum_pg_trigger_tgargs - 1] = DirectFunctionCall1(byteain,
923 CStringGetDatum(""));
924 }
925
926 /* build column number array if it's a column-specific trigger */
927 ncolumns = list_length(stmt->columns);
928 if (ncolumns == 0)
929 columns = NULL;
930 else
931 {
932 ListCell *cell;
933 int i = 0;
934
935 columns = (int16 *) palloc(ncolumns * sizeof(int16));
936 foreach(cell, stmt->columns)
937 {
938 char *name = strVal(lfirst(cell));
939 int16 attnum;
940 int j;
941
942 /* Lookup column name. System columns are not allowed */
943 attnum = attnameAttNum(rel, name, false);
944 if (attnum == InvalidAttrNumber)
945 ereport(ERROR,
946 (errcode(ERRCODE_UNDEFINED_COLUMN),
947 errmsg("column \"%s\" of relation \"%s\" does not exist",
948 name, RelationGetRelationName(rel))));
949
950 /* Check for duplicates */
951 for (j = i - 1; j >= 0; j--)
952 {
953 if (columns[j] == attnum)
954 ereport(ERROR,
955 (errcode(ERRCODE_DUPLICATE_COLUMN),
956 errmsg("column \"%s\" specified more than once",
957 name)));
958 }
959
960 columns[i++] = attnum;
961 }
962 }
963 tgattr = buildint2vector(columns, ncolumns);
964 values[Anum_pg_trigger_tgattr - 1] = PointerGetDatum(tgattr);
965
966 /* set tgqual if trigger has WHEN clause */
967 if (qual)
968 values[Anum_pg_trigger_tgqual - 1] = CStringGetTextDatum(qual);
969 else
970 nulls[Anum_pg_trigger_tgqual - 1] = true;
971
972 if (oldtablename)
973 values[Anum_pg_trigger_tgoldtable - 1] = DirectFunctionCall1(namein,
974 CStringGetDatum(oldtablename));
975 else
976 nulls[Anum_pg_trigger_tgoldtable - 1] = true;
977 if (newtablename)
978 values[Anum_pg_trigger_tgnewtable - 1] = DirectFunctionCall1(namein,
979 CStringGetDatum(newtablename));
980 else
981 nulls[Anum_pg_trigger_tgnewtable - 1] = true;
982
983 /*
984 * Insert or replace tuple in pg_trigger.
985 */
986 if (!trigger_exists)
987 {
988 tuple = heap_form_tuple(tgrel->rd_att, values, nulls);
989 CatalogTupleInsert(tgrel, tuple);
990 }
991 else
992 {
993 HeapTuple newtup;
994
995 newtup = heap_form_tuple(tgrel->rd_att, values, nulls);
996 CatalogTupleUpdate(tgrel, &tuple->t_self, newtup);
997 heap_freetuple(newtup);
998 }
999
1000 heap_freetuple(tuple); /* free either original or new tuple */
1001 table_close(tgrel, RowExclusiveLock);
1002
1003 pfree(DatumGetPointer(values[Anum_pg_trigger_tgname - 1]));
1004 pfree(DatumGetPointer(values[Anum_pg_trigger_tgargs - 1]));
1005 pfree(DatumGetPointer(values[Anum_pg_trigger_tgattr - 1]));
1006 if (oldtablename)
1007 pfree(DatumGetPointer(values[Anum_pg_trigger_tgoldtable - 1]));
1008 if (newtablename)
1009 pfree(DatumGetPointer(values[Anum_pg_trigger_tgnewtable - 1]));
1010
1011 /*
1012 * Update relation's pg_class entry; if necessary; and if not, send an SI
1013 * message to make other backends (and this one) rebuild relcache entries.
1014 */
1015 pgrel = table_open(RelationRelationId, RowExclusiveLock);
1016 tuple = SearchSysCacheCopy1(RELOID,
1017 ObjectIdGetDatum(RelationGetRelid(rel)));
1018 if (!HeapTupleIsValid(tuple))
1019 elog(ERROR, "cache lookup failed for relation %u",
1020 RelationGetRelid(rel));
1021 if (!((Form_pg_class) GETSTRUCT(tuple))->relhastriggers)
1022 {
1023 ((Form_pg_class) GETSTRUCT(tuple))->relhastriggers = true;
1024
1025 CatalogTupleUpdate(pgrel, &tuple->t_self, tuple);
1026
1027 CommandCounterIncrement();
1028 }
1029 else
1030 CacheInvalidateRelcacheByTuple(tuple);
1031
1032 heap_freetuple(tuple);
1033 table_close(pgrel, RowExclusiveLock);
1034
1035 /*
1036 * If we're replacing a trigger, flush all the old dependencies before
1037 * recording new ones.
1038 */
1039 if (trigger_exists)
1040 deleteDependencyRecordsFor(TriggerRelationId, trigoid, true);
1041
1042 /*
1043 * Record dependencies for trigger. Always place a normal dependency on
1044 * the function.
1045 */
1046 myself.classId = TriggerRelationId;
1047 myself.objectId = trigoid;
1048 myself.objectSubId = 0;
1049
1050 referenced.classId = ProcedureRelationId;
1051 referenced.objectId = funcoid;
1052 referenced.objectSubId = 0;
1053 recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
1054
1055 if (isInternal && OidIsValid(constraintOid))
1056 {
1057 /*
1058 * Internally-generated trigger for a constraint, so make it an
1059 * internal dependency of the constraint. We can skip depending on
1060 * the relation(s), as there'll be an indirect dependency via the
1061 * constraint.
1062 */
1063 referenced.classId = ConstraintRelationId;
1064 referenced.objectId = constraintOid;
1065 referenced.objectSubId = 0;
1066 recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL);
1067 }
1068 else
1069 {
1070 /*
1071 * User CREATE TRIGGER, so place dependencies. We make trigger be
1072 * auto-dropped if its relation is dropped or if the FK relation is
1073 * dropped. (Auto drop is compatible with our pre-7.3 behavior.)
1074 */
1075 referenced.classId = RelationRelationId;
1076 referenced.objectId = RelationGetRelid(rel);
1077 referenced.objectSubId = 0;
1078 recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
1079
1080 if (OidIsValid(constrrelid))
1081 {
1082 referenced.classId = RelationRelationId;
1083 referenced.objectId = constrrelid;
1084 referenced.objectSubId = 0;
1085 recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
1086 }
1087 /* Not possible to have an index dependency in this case */
1088 Assert(!OidIsValid(indexOid));
1089
1090 /*
1091 * If it's a user-specified constraint trigger, make the constraint
1092 * internally dependent on the trigger instead of vice versa.
1093 */
1094 if (OidIsValid(constraintOid))
1095 {
1096 referenced.classId = ConstraintRelationId;
1097 referenced.objectId = constraintOid;
1098 referenced.objectSubId = 0;
1099 recordDependencyOn(&referenced, &myself, DEPENDENCY_INTERNAL);
1100 }
1101
1102 /*
1103 * If it's a partition trigger, create the partition dependencies.
1104 */
1105 if (OidIsValid(parentTriggerOid))
1106 {
1107 ObjectAddressSet(referenced, TriggerRelationId, parentTriggerOid);
1108 recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_PRI);
1109 ObjectAddressSet(referenced, RelationRelationId, RelationGetRelid(rel));
1110 recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_SEC);
1111 }
1112 }
1113
1114 /* If column-specific trigger, add normal dependencies on columns */
1115 if (columns != NULL)
1116 {
1117 int i;
1118
1119 referenced.classId = RelationRelationId;
1120 referenced.objectId = RelationGetRelid(rel);
1121 for (i = 0; i < ncolumns; i++)
1122 {
1123 referenced.objectSubId = columns[i];
1124 recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
1125 }
1126 }
1127
1128 /*
1129 * If it has a WHEN clause, add dependencies on objects mentioned in the
1130 * expression (eg, functions, as well as any columns used).
1131 */
1132 if (whenRtable != NIL)
1133 recordDependencyOnExpr(&myself, whenClause, whenRtable,
1134 DEPENDENCY_NORMAL);
1135
1136 /* Post creation hook for new trigger */
1137 InvokeObjectPostCreateHookArg(TriggerRelationId, trigoid, 0,
1138 isInternal);
1139
1140 /*
1141 * Lastly, create the trigger on child relations, if needed.
1142 */
1143 if (partition_recurse)
1144 {
1145 PartitionDesc partdesc = RelationGetPartitionDesc(rel, true);
1146 int i;
1147 MemoryContext oldcxt,
1148 perChildCxt;
1149
1150 perChildCxt = AllocSetContextCreate(CurrentMemoryContext,
1151 "part trig clone",
1152 ALLOCSET_SMALL_SIZES);
1153
1154 /*
1155 * We don't currently expect to be called with a valid indexOid. If
1156 * that ever changes then we'll need to write code here to find the
1157 * corresponding child index.
1158 */
1159 Assert(!OidIsValid(indexOid));
1160
1161 oldcxt = MemoryContextSwitchTo(perChildCxt);
1162
1163 /* Iterate to create the trigger on each existing partition */
1164 for (i = 0; i < partdesc->nparts; i++)
1165 {
1166 CreateTrigStmt *childStmt;
1167 Relation childTbl;
1168 Node *qual;
1169
1170 childTbl = table_open(partdesc->oids[i], ShareRowExclusiveLock);
1171
1172 /*
1173 * Initialize our fabricated parse node by copying the original
1174 * one, then resetting fields that we pass separately.
1175 */
1176 childStmt = copyObject(stmt);
1177 childStmt->funcname = NIL;
1178 childStmt->whenClause = NULL;
1179
1180 /* If there is a WHEN clause, create a modified copy of it */
1181 qual = copyObject(whenClause);
1182 qual = (Node *)
1183 map_partition_varattnos((List *) qual, PRS2_OLD_VARNO,
1184 childTbl, rel);
1185 qual = (Node *)
1186 map_partition_varattnos((List *) qual, PRS2_NEW_VARNO,
1187 childTbl, rel);
1188
1189 CreateTriggerFiringOn(childStmt, queryString,
1190 partdesc->oids[i], refRelOid,
1191 InvalidOid, InvalidOid,
1192 funcoid, trigoid, qual,
1193 isInternal, true, trigger_fires_when);
1194
1195 table_close(childTbl, NoLock);
1196
1197 MemoryContextReset(perChildCxt);
1198 }
1199
1200 MemoryContextSwitchTo(oldcxt);
1201 MemoryContextDelete(perChildCxt);
1202 }
1203
1204 /* Keep lock on target rel until end of xact */
1205 table_close(rel, NoLock);
1206
1207 return myself;
1208}
AclResult
AclResult
Definition: acl.h:182
ACLCHECK_OK
@ ACLCHECK_OK
Definition: acl.h:183
aclcheck_error
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:2652
object_aclcheck
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3834
pg_class_aclcheck
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4037
InvalidAttrNumber
#define InvalidAttrNumber
Definition: attnum.h:23
values
static Datum values[MAXATTR]
Definition: bootstrap.c:153
CStringGetTextDatum
#define CStringGetTextDatum(s)
Definition: builtins.h:97
byteain
Datum byteain(PG_FUNCTION_ARGS)
Definition: bytea.c:187
NameStr
#define NameStr(name)
Definition: c.h:756
OidIsValid
#define OidIsValid(objectId)
Definition: c.h:779
IsSystemRelation
bool IsSystemRelation(Relation relation)
Definition: catalog.c:74
GetNewOidWithIndex
Oid GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
Definition: catalog.c:448
recordDependencyOnExpr
void recordDependencyOnExpr(const ObjectAddress *depender, Node *expr, List *rtable, DependencyType behavior)
Definition: dependency.c:1554
DEPENDENCY_AUTO
@ DEPENDENCY_AUTO
Definition: dependency.h:34
DEPENDENCY_INTERNAL
@ DEPENDENCY_INTERNAL
Definition: dependency.h:35
DEPENDENCY_PARTITION_PRI
@ DEPENDENCY_PARTITION_PRI
Definition: dependency.h:36
DEPENDENCY_PARTITION_SEC
@ DEPENDENCY_PARTITION_SEC
Definition: dependency.h:37
DEPENDENCY_NORMAL
@ DEPENDENCY_NORMAL
Definition: dependency.h:33
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:1216
errhint
int errhint(const char *fmt,...)
Definition: elog.c:1330
elog
#define elog(elevel,...)
Definition: elog.h:226
DirectFunctionCall1
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:682
allowSystemTableMods
bool allowSystemTableMods
Definition: globals.c:130
heap_copytuple
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:778
heap_form_tuple
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1117
heap_freetuple
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1435
CatalogTupleUpdate
void CatalogTupleUpdate(Relation heapRel, const ItemPointerData *otid, HeapTuple tup)
Definition: indexing.c:313
CatalogTupleInsert
void CatalogTupleInsert(Relation heapRel, HeapTuple tup)
Definition: indexing.c:233
buildint2vector
int2vector * buildint2vector(const int16 *int2s, int n)
Definition: int.c:114
CacheInvalidateRelcacheByTuple
void CacheInvalidateRelcacheByTuple(HeapTuple classTuple)
Definition: inval.c:1665
LockRelationOid
void LockRelationOid(Oid relid, LOCKMODE lockmode)
Definition: lmgr.c:107
NoLock
#define NoLock
Definition: lockdefs.h:34
ShareRowExclusiveLock
#define ShareRowExclusiveLock
Definition: lockdefs.h:41
RowExclusiveLock
#define RowExclusiveLock
Definition: lockdefs.h:38
get_rel_name
char * get_rel_name(Oid relid)
Definition: lsyscache.c:2095
get_rel_relkind
char get_rel_relkind(Oid relid)
Definition: lsyscache.c:2170
get_func_rettype
Oid get_func_rettype(Oid funcid)
Definition: lsyscache.c:1822
makeAlias
Alias * makeAlias(const char *aliasname, List *colnames)
Definition: makefuncs.c:438
MemoryContextReset
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:400
CurrentMemoryContext
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
AllocSetContextCreate
#define AllocSetContextCreate
Definition: memutils.h:129
ALLOCSET_SMALL_SIZES
#define ALLOCSET_SMALL_SIZES
Definition: memutils.h:170
GetUserId
Oid GetUserId(void)
Definition: miscinit.c:469
namein
Datum namein(PG_FUNCTION_ARGS)
Definition: name.c:48
NameListToString
char * NameListToString(const List *names)
Definition: namespace.c:3664
RangeVarGetRelid
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Definition: namespace.h:98
generate_unaccent_rules.args
args
Definition: generate_unaccent_rules.py:288
copyObject
#define copyObject(obj)
Definition: nodes.h:232
InvokeObjectPostCreateHookArg
#define InvokeObjectPostCreateHookArg(classId, objectId, subId, is_internal)
Definition: objectaccess.h:175
get_relkind_objtype
ObjectType get_relkind_objtype(char relkind)
Definition: objectaddress.c:6185
ObjectAddressSet
#define ObjectAddressSet(addr, class_id, object_id)
Definition: objectaddress.h:40
nodeToString
char * nodeToString(const void *obj)
Definition: outfuncs.c:805
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
transformWhereClause
Node * transformWhereClause(ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName)
Definition: parse_clause.c:1854
assign_expr_collations
void assign_expr_collations(ParseState *pstate, Node *expr)
Definition: parse_collate.c:177
LookupFuncName
Oid LookupFuncName(List *funcname, int nargs, const Oid *argtypes, bool missing_ok)
Definition: parse_func.c:2269
free_parsestate
void free_parsestate(ParseState *pstate)
Definition: parse_node.c:72
parser_errposition
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
make_parsestate
ParseState * make_parsestate(ParseState *parentParseState)
Definition: parse_node.c:39
EXPR_KIND_TRIGGER_WHEN
@ EXPR_KIND_TRIGGER_WHEN
Definition: parse_node.h:77
addRangeTableEntryForRelation
ParseNamespaceItem * addRangeTableEntryForRelation(ParseState *pstate, Relation rel, int lockmode, Alias *alias, bool inh, bool inFromCl)
Definition: parse_relation.c:1584
addNSItemToQuery
void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)
Definition: parse_relation.c:2710
attnameAttNum
int attnameAttNum(Relation rd, const char *attname, bool sysColOK)
Definition: parse_relation.c:3589
OBJECT_FUNCTION
@ OBJECT_FUNCTION
Definition: parsenodes.h:2344
ACL_EXECUTE
#define ACL_EXECUTE
Definition: parsenodes.h:83
ACL_TRIGGER
#define ACL_TRIGGER
Definition: parsenodes.h:82
RelationGetPartitionDesc
PartitionDesc RelationGetPartitionDesc(Relation rel, bool omit_detached)
Definition: partdesc.c:71
map_partition_varattnos
List * map_partition_varattnos(List *expr, int fromrel_varno, Relation to_rel, Relation from_rel)
Definition: partition.c:222
attnum
int16 attnum
Definition: pg_attribute.h:74
errdetail_relkind_not_supported
int errdetail_relkind_not_supported(char relkind)
Definition: pg_class.c:24
Form_pg_class
FormData_pg_class * Form_pg_class
Definition: pg_class.h:156
NAMEDATALEN
#define NAMEDATALEN
Definition: pg_config_manual.h:39
CreateConstraintEntry
Oid CreateConstraintEntry(const char *constraintName, Oid constraintNamespace, char constraintType, bool isDeferrable, bool isDeferred, bool isEnforced, bool isValidated, Oid parentConstrId, Oid relId, const int16 *constraintKey, int constraintNKeys, int constraintNTotalKeys, Oid domainId, Oid indexRelId, Oid foreignRelId, const int16 *foreignKey, const Oid *pfEqOp, const Oid *ppEqOp, const Oid *ffEqOp, int foreignNKeys, char foreignUpdateType, char foreignDeleteType, const int16 *fkDeleteSetCols, int numFkDeleteSetCols, char foreignMatchType, const Oid *exclOp, Node *conExpr, const char *conBin, bool conIsLocal, int16 conInhCount, bool conNoInherit, bool conPeriod, bool is_internal)
Definition: pg_constraint.c:51
len
const void size_t len
Definition: pg_crc32c_sse42.c:28
recordDependencyOn
void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)
Definition: pg_depend.c:45
deleteDependencyRecordsFor
long deleteDependencyRecordsFor(Oid classId, Oid objectId, bool skipExtensionDeps)
Definition: pg_depend.c:301
find_all_inheritors
List * find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
Definition: pg_inherits.c:255
has_superclass
bool has_superclass(Oid relationId)
Definition: pg_inherits.c:377
lfirst_node
#define lfirst_node(type, lc)
Definition: pg_list.h:176
list_length
static int list_length(const List *l)
Definition: pg_list.h:152
snprintf
#define snprintf
Definition: port.h:239
PointerGetDatum
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
Int16GetDatum
static Datum Int16GetDatum(int16 X)
Definition: postgres.h:182
BoolGetDatum
static Datum BoolGetDatum(bool X)
Definition: postgres.h:112
Datum
uint64_t Datum
Definition: postgres.h:70
DatumGetPointer
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:322
CharGetDatum
static Datum CharGetDatum(char X)
Definition: postgres.h:132
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:37
PRS2_OLD_VARNO
#define PRS2_OLD_VARNO
Definition: primnodes.h:250
PRS2_NEW_VARNO
#define PRS2_NEW_VARNO
Definition: primnodes.h:251
RelationGetRelid
#define RelationGetRelid(relation)
Definition: rel.h:515
RelationGetDescr
#define RelationGetDescr(relation)
Definition: rel.h:541
RelationGetRelationName
#define RelationGetRelationName(relation)
Definition: rel.h:549
RelationGetNamespace
#define RelationGetNamespace(relation)
Definition: rel.h:556
ERRCODE_DUPLICATE_OBJECT
#define ERRCODE_DUPLICATE_OBJECT
Definition: streamutil.c:30
CreateTrigStmt::whenClause
Node * whenClause
Definition: parsenodes.h:3121
HeapTupleData::t_self
ItemPointerData t_self
Definition: htup.h:65
Node
Definition: nodes.h:135
ParseState::p_sourcetext
const char * p_sourcetext
Definition: parse_node.h:195
ParseState::p_rtable
List * p_rtable
Definition: parse_node.h:196
RelationData::rd_att
TupleDesc rd_att
Definition: rel.h:112
RelationData::rd_id
Oid rd_id
Definition: rel.h:113
RelationData::rd_rel
Form_pg_class rd_rel
Definition: rel.h:111
Var
Definition: primnodes.h:262
Var::location
ParseLoc location
Definition: primnodes.h:310
Var::varattno
AttrNumber varattno
Definition: primnodes.h:274
Var::varno
int varno
Definition: primnodes.h:269
int2vector
Definition: c.h:725
SearchSysCacheCopy1
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:91
table_openrv
Relation table_openrv(const RangeVar *relation, LOCKMODE lockmode)
Definition: table.c:83
TupleDescAttr
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:160
strVal
#define strVal(v)
Definition: value.h:82
pull_var_clause
List * pull_var_clause(Node *node, int flags)
Definition: var.c:653
name
const char * name
Definition: wait_event_funcs.c:28
CommandCounterIncrement
void CommandCounterIncrement(void)
Definition: xact.c:1101

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

Referenced by CloneRowTriggersToPartition(), CreateTrigger(), and CreateTriggerFiringOn().

◆ EnableDisableTrigger()

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

Definition at line 1726 of file trigger.c.

1729{
1730 Relation tgrel;
1731 int nkeys;
1732 ScanKeyData keys[2];
1733 SysScanDesc tgscan;
1734 HeapTuple tuple;
1735 bool found;
1736 bool changed;
1737
1738 /* Scan the relevant entries in pg_triggers */
1739 tgrel = table_open(TriggerRelationId, RowExclusiveLock);
1740
1741 ScanKeyInit(&keys[0],
1742 Anum_pg_trigger_tgrelid,
1743 BTEqualStrategyNumber, F_OIDEQ,
1744 ObjectIdGetDatum(RelationGetRelid(rel)));
1745 if (tgname)
1746 {
1747 ScanKeyInit(&keys[1],
1748 Anum_pg_trigger_tgname,
1749 BTEqualStrategyNumber, F_NAMEEQ,
1750 CStringGetDatum(tgname));
1751 nkeys = 2;
1752 }
1753 else
1754 nkeys = 1;
1755
1756 tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
1757 NULL, nkeys, keys);
1758
1759 found = changed = false;
1760
1761 while (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
1762 {
1763 Form_pg_trigger oldtrig = (Form_pg_trigger) GETSTRUCT(tuple);
1764
1765 if (OidIsValid(tgparent) && tgparent != oldtrig->tgparentid)
1766 continue;
1767
1768 if (oldtrig->tgisinternal)
1769 {
1770 /* system trigger ... ok to process? */
1771 if (skip_system)
1772 continue;
1773 if (!superuser())
1774 ereport(ERROR,
1775 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1776 errmsg("permission denied: \"%s\" is a system trigger",
1777 NameStr(oldtrig->tgname))));
1778 }
1779
1780 found = true;
1781
1782 if (oldtrig->tgenabled != fires_when)
1783 {
1784 /* need to change this one ... make a copy to scribble on */
1785 HeapTuple newtup = heap_copytuple(tuple);
1786 Form_pg_trigger newtrig = (Form_pg_trigger) GETSTRUCT(newtup);
1787
1788 newtrig->tgenabled = fires_when;
1789
1790 CatalogTupleUpdate(tgrel, &newtup->t_self, newtup);
1791
1792 heap_freetuple(newtup);
1793
1794 changed = true;
1795 }
1796
1797 /*
1798 * When altering FOR EACH ROW triggers on a partitioned table, do the
1799 * same on the partitions as well, unless ONLY is specified.
1800 *
1801 * Note that we recurse even if we didn't change the trigger above,
1802 * because the partitions' copy of the trigger may have a different
1803 * value of tgenabled than the parent's trigger and thus might need to
1804 * be changed.
1805 */
1806 if (recurse &&
1807 rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
1808 (TRIGGER_FOR_ROW(oldtrig->tgtype)))
1809 {
1810 PartitionDesc partdesc = RelationGetPartitionDesc(rel, true);
1811 int i;
1812
1813 for (i = 0; i < partdesc->nparts; i++)
1814 {
1815 Relation part;
1816
1817 part = relation_open(partdesc->oids[i], lockmode);
1818 /* Match on child triggers' tgparentid, not their name */
1819 EnableDisableTrigger(part, NULL, oldtrig->oid,
1820 fires_when, skip_system, recurse,
1821 lockmode);
1822 table_close(part, NoLock); /* keep lock till commit */
1823 }
1824 }
1825
1826 InvokeObjectPostAlterHook(TriggerRelationId,
1827 oldtrig->oid, 0);
1828 }
1829
1830 systable_endscan(tgscan);
1831
1832 table_close(tgrel, RowExclusiveLock);
1833
1834 if (tgname && !found)
1835 ereport(ERROR,
1836 (errcode(ERRCODE_UNDEFINED_OBJECT),
1837 errmsg("trigger \"%s\" for table \"%s\" does not exist",
1838 tgname, RelationGetRelationName(rel))));
1839
1840 /*
1841 * If we changed anything, broadcast a SI inval message to force each
1842 * backend (including our own!) to rebuild relation's relcache entry.
1843 * Otherwise they will fail to apply the change promptly.
1844 */
1845 if (changed)
1846 CacheInvalidateRelcache(rel);
1847}
CacheInvalidateRelcache
void CacheInvalidateRelcache(Relation relation)
Definition: inval.c:1631
InvokeObjectPostAlterHook
#define InvokeObjectPostAlterHook(classId, objectId, subId)
Definition: objectaccess.h:197
relation_open
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47
superuser
bool superuser(void)
Definition: superuser.c:46
EnableDisableTrigger
void EnableDisableTrigger(Relation rel, const char *tgname, Oid tgparent, char fires_when, bool skip_system, bool recurse, LOCKMODE lockmode)
Definition: trigger.c:1726

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

Referenced by ATExecEnableDisableTrigger(), and EnableDisableTrigger().

◆ ExecARDeleteTriggers()

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

Definition at line 2801 of file trigger.c.

2807{
2808 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2809
2810 if (relinfo->ri_FdwRoutine && transition_capture &&
2811 transition_capture->tcs_delete_old_table)
2812 {
2813 Assert(relinfo->ri_RootResultRelInfo);
2814 ereport(ERROR,
2815 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2816 errmsg("cannot collect transition tuples from child foreign tables")));
2817 }
2818
2819 if ((trigdesc && trigdesc->trig_delete_after_row) ||
2820 (transition_capture && transition_capture->tcs_delete_old_table))
2821 {
2822 TupleTableSlot *slot = ExecGetTriggerOldSlot(estate, relinfo);
2823
2824 Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
2825 if (fdw_trigtuple == NULL)
2826 GetTupleForTrigger(estate,
2827 NULL,
2828 relinfo,
2829 tupleid,
2830 LockTupleExclusive,
2831 slot,
2832 false,
2833 NULL,
2834 NULL,
2835 NULL);
2836 else
2837 ExecForceStoreHeapTuple(fdw_trigtuple, slot, false);
2838
2839 AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
2840 TRIGGER_EVENT_DELETE,
2841 true, slot, NULL, NIL, NULL,
2842 transition_capture,
2843 is_crosspart_update);
2844 }
2845}
ExecForceStoreHeapTuple
void ExecForceStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
Definition: execTuples.c:1658
ExecGetTriggerOldSlot
TupleTableSlot * ExecGetTriggerOldSlot(EState *estate, ResultRelInfo *relInfo)
Definition: execUtils.c:1204
ItemPointerIsValid
static bool ItemPointerIsValid(const ItemPointerData *pointer)
Definition: itemptr.h:83
LockTupleExclusive
@ LockTupleExclusive
Definition: lockoptions.h:58
ResultRelInfo::ri_RootResultRelInfo
struct ResultRelInfo * ri_RootResultRelInfo
Definition: execnodes.h:618
ResultRelInfo::ri_TrigDesc
TriggerDesc * ri_TrigDesc
Definition: execnodes.h:515
ResultRelInfo::ri_FdwRoutine
struct FdwRoutine * ri_FdwRoutine
Definition: execnodes.h:533
TriggerDesc::trig_delete_after_row
bool trig_delete_after_row
Definition: reltrigger.h:67
GetTupleForTrigger
static bool GetTupleForTrigger(EState *estate, EPQState *epqstate, ResultRelInfo *relinfo, ItemPointer tid, LockTupleMode lockmode, TupleTableSlot *oldslot, bool do_epq_recheck, TupleTableSlot **epqslot, TM_Result *tmresultp, TM_FailureData *tmfdp)
Definition: trigger.c:3344
AfterTriggerSaveEvent
static void AfterTriggerSaveEvent(EState *estate, ResultRelInfo *relinfo, ResultRelInfo *src_partinfo, ResultRelInfo *dst_partinfo, int event, bool row_trigger, TupleTableSlot *oldslot, TupleTableSlot *newslot, List *recheckIndexes, Bitmapset *modifiedCols, TransitionCaptureState *transition_capture, bool is_crosspart_update)
Definition: trigger.c:6147
TRIGGER_EVENT_DELETE
#define TRIGGER_EVENT_DELETE
Definition: trigger.h:93

References AfterTriggerSaveEvent(), Assert(), ereport, errcode(), errmsg(), ERROR, ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), GetTupleForTrigger(), HeapTupleIsValid, ItemPointerIsValid(), LockTupleExclusive, NIL, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_TrigDesc, TransitionCaptureState::tcs_delete_old_table, TriggerDesc::trig_delete_after_row, and TRIGGER_EVENT_DELETE.

Referenced by ExecDeleteEpilogue(), and ExecSimpleRelationDelete().

◆ ExecARInsertTriggers()

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

Definition at line 2543 of file trigger.c.

2546{
2547 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2548
2549 if (relinfo->ri_FdwRoutine && transition_capture &&
2550 transition_capture->tcs_insert_new_table)
2551 {
2552 Assert(relinfo->ri_RootResultRelInfo);
2553 ereport(ERROR,
2554 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2555 errmsg("cannot collect transition tuples from child foreign tables")));
2556 }
2557
2558 if ((trigdesc && trigdesc->trig_insert_after_row) ||
2559 (transition_capture && transition_capture->tcs_insert_new_table))
2560 AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
2561 TRIGGER_EVENT_INSERT,
2562 true, NULL, slot,
2563 recheckIndexes, NULL,
2564 transition_capture,
2565 false);
2566}
TriggerDesc::trig_insert_after_row
bool trig_insert_after_row
Definition: reltrigger.h:57
TRIGGER_EVENT_INSERT
#define TRIGGER_EVENT_INSERT
Definition: trigger.h:92

References AfterTriggerSaveEvent(), Assert(), ereport, errcode(), errmsg(), ERROR, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_TrigDesc, TransitionCaptureState::tcs_insert_new_table, TriggerDesc::trig_insert_after_row, and TRIGGER_EVENT_INSERT.

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

◆ ExecARUpdateTriggers()

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

Definition at line 3144 of file trigger.c.

3153{
3154 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
3155
3156 if (relinfo->ri_FdwRoutine && transition_capture &&
3157 (transition_capture->tcs_update_old_table ||
3158 transition_capture->tcs_update_new_table))
3159 {
3160 Assert(relinfo->ri_RootResultRelInfo);
3161 ereport(ERROR,
3162 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3163 errmsg("cannot collect transition tuples from child foreign tables")));
3164 }
3165
3166 if ((trigdesc && trigdesc->trig_update_after_row) ||
3167 (transition_capture &&
3168 (transition_capture->tcs_update_old_table ||
3169 transition_capture->tcs_update_new_table)))
3170 {
3171 /*
3172 * Note: if the UPDATE is converted into a DELETE+INSERT as part of
3173 * update-partition-key operation, then this function is also called
3174 * separately for DELETE and INSERT to capture transition table rows.
3175 * In such case, either old tuple or new tuple can be NULL.
3176 */
3177 TupleTableSlot *oldslot;
3178 ResultRelInfo *tupsrc;
3179
3180 Assert((src_partinfo != NULL && dst_partinfo != NULL) ||
3181 !is_crosspart_update);
3182
3183 tupsrc = src_partinfo ? src_partinfo : relinfo;
3184 oldslot = ExecGetTriggerOldSlot(estate, tupsrc);
3185
3186 if (fdw_trigtuple == NULL && ItemPointerIsValid(tupleid))
3187 GetTupleForTrigger(estate,
3188 NULL,
3189 tupsrc,
3190 tupleid,
3191 LockTupleExclusive,
3192 oldslot,
3193 false,
3194 NULL,
3195 NULL,
3196 NULL);
3197 else if (fdw_trigtuple != NULL)
3198 ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, false);
3199 else
3200 ExecClearTuple(oldslot);
3201
3202 AfterTriggerSaveEvent(estate, relinfo,
3203 src_partinfo, dst_partinfo,
3204 TRIGGER_EVENT_UPDATE,
3205 true,
3206 oldslot, newslot, recheckIndexes,
3207 ExecGetAllUpdatedCols(relinfo, estate),
3208 transition_capture,
3209 is_crosspart_update);
3210 }
3211}
ExecGetAllUpdatedCols
Bitmapset * ExecGetAllUpdatedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1418
TriggerDesc::trig_update_after_row
bool trig_update_after_row
Definition: reltrigger.h:62
TRIGGER_EVENT_UPDATE
#define TRIGGER_EVENT_UPDATE
Definition: trigger.h:94
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:457

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

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

◆ ExecASDeleteTriggers()

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

Definition at line 2681 of file trigger.c.

2683{
2684 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2685
2686 if (trigdesc && trigdesc->trig_delete_after_statement)
2687 AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
2688 TRIGGER_EVENT_DELETE,
2689 false, NULL, NULL, NIL, NULL, transition_capture,
2690 false);
2691}
TriggerDesc::trig_delete_after_statement
bool trig_delete_after_statement
Definition: reltrigger.h:70

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

Referenced by fireASTriggers().

◆ ExecASInsertTriggers()

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

Definition at line 2452 of file trigger.c.

2454{
2455 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2456
2457 if (trigdesc && trigdesc->trig_insert_after_statement)
2458 AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
2459 TRIGGER_EVENT_INSERT,
2460 false, NULL, NULL, NIL, NULL, transition_capture,
2461 false);
2462}
TriggerDesc::trig_insert_after_statement
bool trig_insert_after_statement
Definition: reltrigger.h:60

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

Referenced by CopyFrom(), and fireASTriggers().

◆ ExecASTruncateTriggers()

void ExecASTruncateTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)

Definition at line 3327 of file trigger.c.

3328{
3329 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
3330
3331 if (trigdesc && trigdesc->trig_truncate_after_statement)
3332 AfterTriggerSaveEvent(estate, relinfo,
3333 NULL, NULL,
3334 TRIGGER_EVENT_TRUNCATE,
3335 false, NULL, NULL, NIL, NULL, NULL,
3336 false);
3337}
TriggerDesc::trig_truncate_after_statement
bool trig_truncate_after_statement
Definition: reltrigger.h:73
TRIGGER_EVENT_TRUNCATE
#define TRIGGER_EVENT_TRUNCATE
Definition: trigger.h:95

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

Referenced by ExecuteTruncateGuts().

◆ ExecASUpdateTriggers()

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

Definition at line 2953 of file trigger.c.

2955{
2956 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2957
2958 /* statement-level triggers operate on the parent table */
2959 Assert(relinfo->ri_RootResultRelInfo == NULL);
2960
2961 if (trigdesc && trigdesc->trig_update_after_statement)
2962 AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
2963 TRIGGER_EVENT_UPDATE,
2964 false, NULL, NULL, NIL,
2965 ExecGetAllUpdatedCols(relinfo, estate),
2966 transition_capture,
2967 false);
2968}
TriggerDesc::trig_update_after_statement
bool trig_update_after_statement
Definition: reltrigger.h:65

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

Referenced by fireASTriggers().

◆ ExecBRDeleteTriggers()

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

Definition at line 2701 of file trigger.c.

2709{
2710 TupleTableSlot *slot = ExecGetTriggerOldSlot(estate, relinfo);
2711 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2712 bool result = true;
2713 TriggerData LocTriggerData = {0};
2714 HeapTuple trigtuple;
2715 bool should_free = false;
2716 int i;
2717
2718 Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
2719 if (fdw_trigtuple == NULL)
2720 {
2721 TupleTableSlot *epqslot_candidate = NULL;
2722
2723 /*
2724 * Get a copy of the on-disk tuple we are planning to delete. In
2725 * general, if the tuple has been concurrently updated, we should
2726 * recheck it using EPQ. However, if this is a MERGE DELETE action,
2727 * we skip this EPQ recheck and leave it to the caller (it must do
2728 * additional rechecking, and might end up executing a different
2729 * action entirely).
2730 */
2731 if (!GetTupleForTrigger(estate, epqstate, relinfo, tupleid,
2732 LockTupleExclusive, slot, !is_merge_delete,
2733 &epqslot_candidate, tmresult, tmfd))
2734 return false;
2735
2736 /*
2737 * If the tuple was concurrently updated and the caller of this
2738 * function requested for the updated tuple, skip the trigger
2739 * execution.
2740 */
2741 if (epqslot_candidate != NULL && epqslot != NULL)
2742 {
2743 *epqslot = epqslot_candidate;
2744 return false;
2745 }
2746
2747 trigtuple = ExecFetchSlotHeapTuple(slot, true, &should_free);
2748 }
2749 else
2750 {
2751 trigtuple = fdw_trigtuple;
2752 ExecForceStoreHeapTuple(trigtuple, slot, false);
2753 }
2754
2755 LocTriggerData.type = T_TriggerData;
2756 LocTriggerData.tg_event = TRIGGER_EVENT_DELETE |
2757 TRIGGER_EVENT_ROW |
2758 TRIGGER_EVENT_BEFORE;
2759 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
2760 for (i = 0; i < trigdesc->numtriggers; i++)
2761 {
2762 HeapTuple newtuple;
2763 Trigger *trigger = &trigdesc->triggers[i];
2764
2765 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
2766 TRIGGER_TYPE_ROW,
2767 TRIGGER_TYPE_BEFORE,
2768 TRIGGER_TYPE_DELETE))
2769 continue;
2770 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
2771 NULL, slot, NULL))
2772 continue;
2773
2774 LocTriggerData.tg_trigslot = slot;
2775 LocTriggerData.tg_trigtuple = trigtuple;
2776 LocTriggerData.tg_trigger = trigger;
2777 newtuple = ExecCallTriggerFunc(&LocTriggerData,
2778 i,
2779 relinfo->ri_TrigFunctions,
2780 relinfo->ri_TrigInstrument,
2781 GetPerTupleMemoryContext(estate));
2782 if (newtuple == NULL)
2783 {
2784 result = false; /* tell caller to suppress delete */
2785 break;
2786 }
2787 if (newtuple != trigtuple)
2788 heap_freetuple(newtuple);
2789 }
2790 if (should_free)
2791 heap_freetuple(trigtuple);
2792
2793 return result;
2794}
ExecFetchSlotHeapTuple
HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
Definition: execTuples.c:1833
GetPerTupleMemoryContext
#define GetPerTupleMemoryContext(estate)
Definition: executor.h:661
ResultRelInfo::ri_TrigInstrument
Instrumentation * ri_TrigInstrument
Definition: execnodes.h:524
ResultRelInfo::ri_RelationDesc
Relation ri_RelationDesc
Definition: execnodes.h:480
ResultRelInfo::ri_TrigFunctions
FmgrInfo * ri_TrigFunctions
Definition: execnodes.h:518
TriggerData::type
NodeTag type
Definition: trigger.h:33
TriggerData::tg_relation
Relation tg_relation
Definition: trigger.h:35
TriggerData::tg_event
TriggerEvent tg_event
Definition: trigger.h:34
TriggerData::tg_trigslot
TupleTableSlot * tg_trigslot
Definition: trigger.h:39
TriggerData::tg_trigger
Trigger * tg_trigger
Definition: trigger.h:38
TriggerData::tg_trigtuple
HeapTuple tg_trigtuple
Definition: trigger.h:36
Trigger::tgtype
int16 tgtype
Definition: reltrigger.h:29
TriggerEnabled
static bool TriggerEnabled(EState *estate, ResultRelInfo *relinfo, Trigger *trigger, TriggerEvent event, Bitmapset *modifiedCols, TupleTableSlot *oldslot, TupleTableSlot *newslot)
Definition: trigger.c:3482
ExecCallTriggerFunc
static HeapTuple ExecCallTriggerFunc(TriggerData *trigdata, int tgindx, FmgrInfo *finfo, Instrumentation *instr, MemoryContext per_tuple_context)
Definition: trigger.c:2309
TRIGGER_EVENT_ROW
#define TRIGGER_EVENT_ROW
Definition: trigger.h:98
TRIGGER_EVENT_BEFORE
#define TRIGGER_EVENT_BEFORE
Definition: trigger.h:100

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

Referenced by ExecDeletePrologue(), and ExecSimpleRelationDelete().

◆ ExecBRInsertTriggers()

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

Definition at line 2465 of file trigger.c.

2467{
2468 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2469 HeapTuple newtuple = NULL;
2470 bool should_free;
2471 TriggerData LocTriggerData = {0};
2472 int i;
2473
2474 LocTriggerData.type = T_TriggerData;
2475 LocTriggerData.tg_event = TRIGGER_EVENT_INSERT |
2476 TRIGGER_EVENT_ROW |
2477 TRIGGER_EVENT_BEFORE;
2478 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
2479 for (i = 0; i < trigdesc->numtriggers; i++)
2480 {
2481 Trigger *trigger = &trigdesc->triggers[i];
2482 HeapTuple oldtuple;
2483
2484 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
2485 TRIGGER_TYPE_ROW,
2486 TRIGGER_TYPE_BEFORE,
2487 TRIGGER_TYPE_INSERT))
2488 continue;
2489 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
2490 NULL, NULL, slot))
2491 continue;
2492
2493 if (!newtuple)
2494 newtuple = ExecFetchSlotHeapTuple(slot, true, &should_free);
2495
2496 LocTriggerData.tg_trigslot = slot;
2497 LocTriggerData.tg_trigtuple = oldtuple = newtuple;
2498 LocTriggerData.tg_trigger = trigger;
2499 newtuple = ExecCallTriggerFunc(&LocTriggerData,
2500 i,
2501 relinfo->ri_TrigFunctions,
2502 relinfo->ri_TrigInstrument,
2503 GetPerTupleMemoryContext(estate));
2504 if (newtuple == NULL)
2505 {
2506 if (should_free)
2507 heap_freetuple(oldtuple);
2508 return false; /* "do nothing" */
2509 }
2510 else if (newtuple != oldtuple)
2511 {
2512 newtuple = check_modified_virtual_generated(RelationGetDescr(relinfo->ri_RelationDesc), newtuple);
2513
2514 ExecForceStoreHeapTuple(newtuple, slot, false);
2515
2516 /*
2517 * After a tuple in a partition goes through a trigger, the user
2518 * could have changed the partition key enough that the tuple no
2519 * longer fits the partition. Verify that.
2520 */
2521 if (trigger->tgisclone &&
2522 !ExecPartitionCheck(relinfo, slot, estate, false))
2523 ereport(ERROR,
2524 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2525 errmsg("moving row to another partition during a BEFORE FOR EACH ROW trigger is not supported"),
2526 errdetail("Before executing trigger \"%s\", the row was to be in partition \"%s.%s\".",
2527 trigger->tgname,
2528 get_namespace_name(RelationGetNamespace(relinfo->ri_RelationDesc)),
2529 RelationGetRelationName(relinfo->ri_RelationDesc))));
2530
2531 if (should_free)
2532 heap_freetuple(oldtuple);
2533
2534 /* signal tuple should be re-fetched if used */
2535 newtuple = NULL;
2536 }
2537 }
2538
2539 return true;
2540}
ExecPartitionCheck
bool ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, bool emitError)
Definition: execMain.c:1856
get_namespace_name
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3533
Trigger::tgisclone
bool tgisclone
Definition: reltrigger.h:32
check_modified_virtual_generated
static HeapTuple check_modified_virtual_generated(TupleDesc tupdesc, HeapTuple tuple)
Definition: trigger.c:6696

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

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

◆ ExecBRUpdateTriggers()

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

Definition at line 2971 of file trigger.c.

2979{
2980 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2981 TupleTableSlot *oldslot = ExecGetTriggerOldSlot(estate, relinfo);
2982 HeapTuple newtuple = NULL;
2983 HeapTuple trigtuple;
2984 bool should_free_trig = false;
2985 bool should_free_new = false;
2986 TriggerData LocTriggerData = {0};
2987 int i;
2988 Bitmapset *updatedCols;
2989 LockTupleMode lockmode;
2990
2991 /* Determine lock mode to use */
2992 lockmode = ExecUpdateLockMode(estate, relinfo);
2993
2994 Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
2995 if (fdw_trigtuple == NULL)
2996 {
2997 TupleTableSlot *epqslot_candidate = NULL;
2998
2999 /*
3000 * Get a copy of the on-disk tuple we are planning to update. In
3001 * general, if the tuple has been concurrently updated, we should
3002 * recheck it using EPQ. However, if this is a MERGE UPDATE action,
3003 * we skip this EPQ recheck and leave it to the caller (it must do
3004 * additional rechecking, and might end up executing a different
3005 * action entirely).
3006 */
3007 if (!GetTupleForTrigger(estate, epqstate, relinfo, tupleid,
3008 lockmode, oldslot, !is_merge_update,
3009 &epqslot_candidate, tmresult, tmfd))
3010 return false; /* cancel the update action */
3011
3012 /*
3013 * In READ COMMITTED isolation level it's possible that target tuple
3014 * was changed due to concurrent update. In that case we have a raw
3015 * subplan output tuple in epqslot_candidate, and need to form a new
3016 * insertable tuple using ExecGetUpdateNewTuple to replace the one we
3017 * received in newslot. Neither we nor our callers have any further
3018 * interest in the passed-in tuple, so it's okay to overwrite newslot
3019 * with the newer data.
3020 */
3021 if (epqslot_candidate != NULL)
3022 {
3023 TupleTableSlot *epqslot_clean;
3024
3025 epqslot_clean = ExecGetUpdateNewTuple(relinfo, epqslot_candidate,
3026 oldslot);
3027
3028 /*
3029 * Typically, the caller's newslot was also generated by
3030 * ExecGetUpdateNewTuple, so that epqslot_clean will be the same
3031 * slot and copying is not needed. But do the right thing if it
3032 * isn't.
3033 */
3034 if (unlikely(newslot != epqslot_clean))
3035 ExecCopySlot(newslot, epqslot_clean);
3036
3037 /*
3038 * At this point newslot contains a virtual tuple that may
3039 * reference some fields of oldslot's tuple in some disk buffer.
3040 * If that tuple is in a different page than the original target
3041 * tuple, then our only pin on that buffer is oldslot's, and we're
3042 * about to release it. Hence we'd better materialize newslot to
3043 * ensure it doesn't contain references into an unpinned buffer.
3044 * (We'd materialize it below anyway, but too late for safety.)
3045 */
3046 ExecMaterializeSlot(newslot);
3047 }
3048
3049 /*
3050 * Here we convert oldslot to a materialized slot holding trigtuple.
3051 * Neither slot passed to the triggers will hold any buffer pin.
3052 */
3053 trigtuple = ExecFetchSlotHeapTuple(oldslot, true, &should_free_trig);
3054 }
3055 else
3056 {
3057 /* Put the FDW-supplied tuple into oldslot to unify the cases */
3058 ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, false);
3059 trigtuple = fdw_trigtuple;
3060 }
3061
3062 LocTriggerData.type = T_TriggerData;
3063 LocTriggerData.tg_event = TRIGGER_EVENT_UPDATE |
3064 TRIGGER_EVENT_ROW |
3065 TRIGGER_EVENT_BEFORE;
3066 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
3067 updatedCols = ExecGetAllUpdatedCols(relinfo, estate);
3068 LocTriggerData.tg_updatedcols = updatedCols;
3069 for (i = 0; i < trigdesc->numtriggers; i++)
3070 {
3071 Trigger *trigger = &trigdesc->triggers[i];
3072 HeapTuple oldtuple;
3073
3074 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
3075 TRIGGER_TYPE_ROW,
3076 TRIGGER_TYPE_BEFORE,
3077 TRIGGER_TYPE_UPDATE))
3078 continue;
3079 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
3080 updatedCols, oldslot, newslot))
3081 continue;
3082
3083 if (!newtuple)
3084 newtuple = ExecFetchSlotHeapTuple(newslot, true, &should_free_new);
3085
3086 LocTriggerData.tg_trigslot = oldslot;
3087 LocTriggerData.tg_trigtuple = trigtuple;
3088 LocTriggerData.tg_newtuple = oldtuple = newtuple;
3089 LocTriggerData.tg_newslot = newslot;
3090 LocTriggerData.tg_trigger = trigger;
3091 newtuple = ExecCallTriggerFunc(&LocTriggerData,
3092 i,
3093 relinfo->ri_TrigFunctions,
3094 relinfo->ri_TrigInstrument,
3095 GetPerTupleMemoryContext(estate));
3096
3097 if (newtuple == NULL)
3098 {
3099 if (should_free_trig)
3100 heap_freetuple(trigtuple);
3101 if (should_free_new)
3102 heap_freetuple(oldtuple);
3103 return false; /* "do nothing" */
3104 }
3105 else if (newtuple != oldtuple)
3106 {
3107 newtuple = check_modified_virtual_generated(RelationGetDescr(relinfo->ri_RelationDesc), newtuple);
3108
3109 ExecForceStoreHeapTuple(newtuple, newslot, false);
3110
3111 /*
3112 * If the tuple returned by the trigger / being stored, is the old
3113 * row version, and the heap tuple passed to the trigger was
3114 * allocated locally, materialize the slot. Otherwise we might
3115 * free it while still referenced by the slot.
3116 */
3117 if (should_free_trig && newtuple == trigtuple)
3118 ExecMaterializeSlot(newslot);
3119
3120 if (should_free_new)
3121 heap_freetuple(oldtuple);
3122
3123 /* signal tuple should be re-fetched if used */
3124 newtuple = NULL;
3125 }
3126 }
3127 if (should_free_trig)
3128 heap_freetuple(trigtuple);
3129
3130 return true;
3131}
unlikely
#define unlikely(x)
Definition: c.h:407
ExecUpdateLockMode
LockTupleMode ExecUpdateLockMode(EState *estate, ResultRelInfo *relinfo)
Definition: execMain.c:2530
LockTupleMode
LockTupleMode
Definition: lockoptions.h:50
ExecGetUpdateNewTuple
TupleTableSlot * ExecGetUpdateNewTuple(ResultRelInfo *relinfo, TupleTableSlot *planSlot, TupleTableSlot *oldSlot)
Definition: nodeModifyTable.c:812
TriggerData::tg_updatedcols
const Bitmapset * tg_updatedcols
Definition: trigger.h:43
TriggerData::tg_newtuple
HeapTuple tg_newtuple
Definition: trigger.h:37
TriggerData::tg_newslot
TupleTableSlot * tg_newslot
Definition: trigger.h:40
ExecCopySlot
static TupleTableSlot * ExecCopySlot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition: tuptable.h:524
ExecMaterializeSlot
static void ExecMaterializeSlot(TupleTableSlot *slot)
Definition: tuptable.h:475

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

Referenced by ExecSimpleRelationUpdate(), and ExecUpdatePrologue().

◆ ExecBSDeleteTriggers()

void ExecBSDeleteTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)

Definition at line 2630 of file trigger.c.

2631{
2632 TriggerDesc *trigdesc;
2633 int i;
2634 TriggerData LocTriggerData = {0};
2635
2636 trigdesc = relinfo->ri_TrigDesc;
2637
2638 if (trigdesc == NULL)
2639 return;
2640 if (!trigdesc->trig_delete_before_statement)
2641 return;
2642
2643 /* no-op if we already fired BS triggers in this context */
2644 if (before_stmt_triggers_fired(RelationGetRelid(relinfo->ri_RelationDesc),
2645 CMD_DELETE))
2646 return;
2647
2648 LocTriggerData.type = T_TriggerData;
2649 LocTriggerData.tg_event = TRIGGER_EVENT_DELETE |
2650 TRIGGER_EVENT_BEFORE;
2651 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
2652 for (i = 0; i < trigdesc->numtriggers; i++)
2653 {
2654 Trigger *trigger = &trigdesc->triggers[i];
2655 HeapTuple newtuple;
2656
2657 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
2658 TRIGGER_TYPE_STATEMENT,
2659 TRIGGER_TYPE_BEFORE,
2660 TRIGGER_TYPE_DELETE))
2661 continue;
2662 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
2663 NULL, NULL, NULL))
2664 continue;
2665
2666 LocTriggerData.tg_trigger = trigger;
2667 newtuple = ExecCallTriggerFunc(&LocTriggerData,
2668 i,
2669 relinfo->ri_TrigFunctions,
2670 relinfo->ri_TrigInstrument,
2671 GetPerTupleMemoryContext(estate));
2672
2673 if (newtuple)
2674 ereport(ERROR,
2675 (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
2676 errmsg("BEFORE STATEMENT trigger cannot return a value")));
2677 }
2678}
CMD_DELETE
@ CMD_DELETE
Definition: nodes.h:278
TriggerDesc::trig_delete_before_statement
bool trig_delete_before_statement
Definition: reltrigger.h:69
before_stmt_triggers_fired
static bool before_stmt_triggers_fired(Oid relid, CmdType cmdType)
Definition: trigger.c:6545

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

Referenced by fireBSTriggers().

◆ ExecBSInsertTriggers()

void ExecBSInsertTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)

Definition at line 2401 of file trigger.c.

2402{
2403 TriggerDesc *trigdesc;
2404 int i;
2405 TriggerData LocTriggerData = {0};
2406
2407 trigdesc = relinfo->ri_TrigDesc;
2408
2409 if (trigdesc == NULL)
2410 return;
2411 if (!trigdesc->trig_insert_before_statement)
2412 return;
2413
2414 /* no-op if we already fired BS triggers in this context */
2415 if (before_stmt_triggers_fired(RelationGetRelid(relinfo->ri_RelationDesc),
2416 CMD_INSERT))
2417 return;
2418
2419 LocTriggerData.type = T_TriggerData;
2420 LocTriggerData.tg_event = TRIGGER_EVENT_INSERT |
2421 TRIGGER_EVENT_BEFORE;
2422 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
2423 for (i = 0; i < trigdesc->numtriggers; i++)
2424 {
2425 Trigger *trigger = &trigdesc->triggers[i];
2426 HeapTuple newtuple;
2427
2428 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
2429 TRIGGER_TYPE_STATEMENT,
2430 TRIGGER_TYPE_BEFORE,
2431 TRIGGER_TYPE_INSERT))
2432 continue;
2433 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
2434 NULL, NULL, NULL))
2435 continue;
2436
2437 LocTriggerData.tg_trigger = trigger;
2438 newtuple = ExecCallTriggerFunc(&LocTriggerData,
2439 i,
2440 relinfo->ri_TrigFunctions,
2441 relinfo->ri_TrigInstrument,
2442 GetPerTupleMemoryContext(estate));
2443
2444 if (newtuple)
2445 ereport(ERROR,
2446 (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
2447 errmsg("BEFORE STATEMENT trigger cannot return a value")));
2448 }
2449}
CMD_INSERT
@ CMD_INSERT
Definition: nodes.h:277
TriggerDesc::trig_insert_before_statement
bool trig_insert_before_statement
Definition: reltrigger.h:59

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

Referenced by CopyFrom(), and fireBSTriggers().

◆ ExecBSTruncateTriggers()

void ExecBSTruncateTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)

Definition at line 3280 of file trigger.c.

3281{
3282 TriggerDesc *trigdesc;
3283 int i;
3284 TriggerData LocTriggerData = {0};
3285
3286 trigdesc = relinfo->ri_TrigDesc;
3287
3288 if (trigdesc == NULL)
3289 return;
3290 if (!trigdesc->trig_truncate_before_statement)
3291 return;
3292
3293 LocTriggerData.type = T_TriggerData;
3294 LocTriggerData.tg_event = TRIGGER_EVENT_TRUNCATE |
3295 TRIGGER_EVENT_BEFORE;
3296 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
3297
3298 for (i = 0; i < trigdesc->numtriggers; i++)
3299 {
3300 Trigger *trigger = &trigdesc->triggers[i];
3301 HeapTuple newtuple;
3302
3303 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
3304 TRIGGER_TYPE_STATEMENT,
3305 TRIGGER_TYPE_BEFORE,
3306 TRIGGER_TYPE_TRUNCATE))
3307 continue;
3308 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
3309 NULL, NULL, NULL))
3310 continue;
3311
3312 LocTriggerData.tg_trigger = trigger;
3313 newtuple = ExecCallTriggerFunc(&LocTriggerData,
3314 i,
3315 relinfo->ri_TrigFunctions,
3316 relinfo->ri_TrigInstrument,
3317 GetPerTupleMemoryContext(estate));
3318
3319 if (newtuple)
3320 ereport(ERROR,
3321 (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
3322 errmsg("BEFORE STATEMENT trigger cannot return a value")));
3323 }
3324}
TriggerDesc::trig_truncate_before_statement
bool trig_truncate_before_statement
Definition: reltrigger.h:72

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

Referenced by ExecuteTruncateGuts().

◆ ExecBSUpdateTriggers()

void ExecBSUpdateTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)

Definition at line 2895 of file trigger.c.

2896{
2897 TriggerDesc *trigdesc;
2898 int i;
2899 TriggerData LocTriggerData = {0};
2900 Bitmapset *updatedCols;
2901
2902 trigdesc = relinfo->ri_TrigDesc;
2903
2904 if (trigdesc == NULL)
2905 return;
2906 if (!trigdesc->trig_update_before_statement)
2907 return;
2908
2909 /* no-op if we already fired BS triggers in this context */
2910 if (before_stmt_triggers_fired(RelationGetRelid(relinfo->ri_RelationDesc),
2911 CMD_UPDATE))
2912 return;
2913
2914 /* statement-level triggers operate on the parent table */
2915 Assert(relinfo->ri_RootResultRelInfo == NULL);
2916
2917 updatedCols = ExecGetAllUpdatedCols(relinfo, estate);
2918
2919 LocTriggerData.type = T_TriggerData;
2920 LocTriggerData.tg_event = TRIGGER_EVENT_UPDATE |
2921 TRIGGER_EVENT_BEFORE;
2922 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
2923 LocTriggerData.tg_updatedcols = updatedCols;
2924 for (i = 0; i < trigdesc->numtriggers; i++)
2925 {
2926 Trigger *trigger = &trigdesc->triggers[i];
2927 HeapTuple newtuple;
2928
2929 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
2930 TRIGGER_TYPE_STATEMENT,
2931 TRIGGER_TYPE_BEFORE,
2932 TRIGGER_TYPE_UPDATE))
2933 continue;
2934 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
2935 updatedCols, NULL, NULL))
2936 continue;
2937
2938 LocTriggerData.tg_trigger = trigger;
2939 newtuple = ExecCallTriggerFunc(&LocTriggerData,
2940 i,
2941 relinfo->ri_TrigFunctions,
2942 relinfo->ri_TrigInstrument,
2943 GetPerTupleMemoryContext(estate));
2944
2945 if (newtuple)
2946 ereport(ERROR,
2947 (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
2948 errmsg("BEFORE STATEMENT trigger cannot return a value")));
2949 }
2950}
CMD_UPDATE
@ CMD_UPDATE
Definition: nodes.h:276
TriggerDesc::trig_update_before_statement
bool trig_update_before_statement
Definition: reltrigger.h:64

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

Referenced by fireBSTriggers().

◆ ExecIRDeleteTriggers()

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

Definition at line 2848 of file trigger.c.

2850{
2851 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2852 TupleTableSlot *slot = ExecGetTriggerOldSlot(estate, relinfo);
2853 TriggerData LocTriggerData = {0};
2854 int i;
2855
2856 LocTriggerData.type = T_TriggerData;
2857 LocTriggerData.tg_event = TRIGGER_EVENT_DELETE |
2858 TRIGGER_EVENT_ROW |
2859 TRIGGER_EVENT_INSTEAD;
2860 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
2861
2862 ExecForceStoreHeapTuple(trigtuple, slot, false);
2863
2864 for (i = 0; i < trigdesc->numtriggers; i++)
2865 {
2866 HeapTuple rettuple;
2867 Trigger *trigger = &trigdesc->triggers[i];
2868
2869 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
2870 TRIGGER_TYPE_ROW,
2871 TRIGGER_TYPE_INSTEAD,
2872 TRIGGER_TYPE_DELETE))
2873 continue;
2874 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
2875 NULL, slot, NULL))
2876 continue;
2877
2878 LocTriggerData.tg_trigslot = slot;
2879 LocTriggerData.tg_trigtuple = trigtuple;
2880 LocTriggerData.tg_trigger = trigger;
2881 rettuple = ExecCallTriggerFunc(&LocTriggerData,
2882 i,
2883 relinfo->ri_TrigFunctions,
2884 relinfo->ri_TrigInstrument,
2885 GetPerTupleMemoryContext(estate));
2886 if (rettuple == NULL)
2887 return false; /* Delete was suppressed */
2888 if (rettuple != trigtuple)
2889 heap_freetuple(rettuple);
2890 }
2891 return true;
2892}
TRIGGER_EVENT_INSTEAD
#define TRIGGER_EVENT_INSTEAD
Definition: trigger.h:102

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

Referenced by ExecDelete(), and ExecMergeMatched().

◆ ExecIRInsertTriggers()

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

Definition at line 2569 of file trigger.c.

2571{
2572 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
2573 HeapTuple newtuple = NULL;
2574 bool should_free;
2575 TriggerData LocTriggerData = {0};
2576 int i;
2577
2578 LocTriggerData.type = T_TriggerData;
2579 LocTriggerData.tg_event = TRIGGER_EVENT_INSERT |
2580 TRIGGER_EVENT_ROW |
2581 TRIGGER_EVENT_INSTEAD;
2582 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
2583 for (i = 0; i < trigdesc->numtriggers; i++)
2584 {
2585 Trigger *trigger = &trigdesc->triggers[i];
2586 HeapTuple oldtuple;
2587
2588 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
2589 TRIGGER_TYPE_ROW,
2590 TRIGGER_TYPE_INSTEAD,
2591 TRIGGER_TYPE_INSERT))
2592 continue;
2593 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
2594 NULL, NULL, slot))
2595 continue;
2596
2597 if (!newtuple)
2598 newtuple = ExecFetchSlotHeapTuple(slot, true, &should_free);
2599
2600 LocTriggerData.tg_trigslot = slot;
2601 LocTriggerData.tg_trigtuple = oldtuple = newtuple;
2602 LocTriggerData.tg_trigger = trigger;
2603 newtuple = ExecCallTriggerFunc(&LocTriggerData,
2604 i,
2605 relinfo->ri_TrigFunctions,
2606 relinfo->ri_TrigInstrument,
2607 GetPerTupleMemoryContext(estate));
2608 if (newtuple == NULL)
2609 {
2610 if (should_free)
2611 heap_freetuple(oldtuple);
2612 return false; /* "do nothing" */
2613 }
2614 else if (newtuple != oldtuple)
2615 {
2616 ExecForceStoreHeapTuple(newtuple, slot, false);
2617
2618 if (should_free)
2619 heap_freetuple(oldtuple);
2620
2621 /* signal tuple should be re-fetched if used */
2622 newtuple = NULL;
2623 }
2624 }
2625
2626 return true;
2627}

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

Referenced by CopyFrom(), and ExecInsert().

◆ ExecIRUpdateTriggers()

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

Definition at line 3214 of file trigger.c.

3216{
3217 TriggerDesc *trigdesc = relinfo->ri_TrigDesc;
3218 TupleTableSlot *oldslot = ExecGetTriggerOldSlot(estate, relinfo);
3219 HeapTuple newtuple = NULL;
3220 bool should_free;
3221 TriggerData LocTriggerData = {0};
3222 int i;
3223
3224 LocTriggerData.type = T_TriggerData;
3225 LocTriggerData.tg_event = TRIGGER_EVENT_UPDATE |
3226 TRIGGER_EVENT_ROW |
3227 TRIGGER_EVENT_INSTEAD;
3228 LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
3229
3230 ExecForceStoreHeapTuple(trigtuple, oldslot, false);
3231
3232 for (i = 0; i < trigdesc->numtriggers; i++)
3233 {
3234 Trigger *trigger = &trigdesc->triggers[i];
3235 HeapTuple oldtuple;
3236
3237 if (!TRIGGER_TYPE_MATCHES(trigger->tgtype,
3238 TRIGGER_TYPE_ROW,
3239 TRIGGER_TYPE_INSTEAD,
3240 TRIGGER_TYPE_UPDATE))
3241 continue;
3242 if (!TriggerEnabled(estate, relinfo, trigger, LocTriggerData.tg_event,
3243 NULL, oldslot, newslot))
3244 continue;
3245
3246 if (!newtuple)
3247 newtuple = ExecFetchSlotHeapTuple(newslot, true, &should_free);
3248
3249 LocTriggerData.tg_trigslot = oldslot;
3250 LocTriggerData.tg_trigtuple = trigtuple;
3251 LocTriggerData.tg_newslot = newslot;
3252 LocTriggerData.tg_newtuple = oldtuple = newtuple;
3253
3254 LocTriggerData.tg_trigger = trigger;
3255 newtuple = ExecCallTriggerFunc(&LocTriggerData,
3256 i,
3257 relinfo->ri_TrigFunctions,
3258 relinfo->ri_TrigInstrument,
3259 GetPerTupleMemoryContext(estate));
3260 if (newtuple == NULL)
3261 {
3262 return false; /* "do nothing" */
3263 }
3264 else if (newtuple != oldtuple)
3265 {
3266 ExecForceStoreHeapTuple(newtuple, newslot, false);
3267
3268 if (should_free)
3269 heap_freetuple(oldtuple);
3270
3271 /* signal tuple should be re-fetched if used */
3272 newtuple = NULL;
3273 }
3274 }
3275
3276 return true;
3277}

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

Referenced by ExecMergeMatched(), and ExecUpdate().

◆ FindTriggerIncompatibleWithInheritance()

const char * FindTriggerIncompatibleWithInheritance ( TriggerDesc *  trigdesc)

Definition at line 2277 of file trigger.c.

2278{
2279 if (trigdesc != NULL)
2280 {
2281 int i;
2282
2283 for (i = 0; i < trigdesc->numtriggers; ++i)
2284 {
2285 Trigger *trigger = &trigdesc->triggers[i];
2286
2287 if (!TRIGGER_FOR_ROW(trigger->tgtype))
2288 continue;
2289 if (trigger->tgoldtable != NULL || trigger->tgnewtable != NULL)
2290 return trigger->tgname;
2291 }
2292 }
2293
2294 return NULL;
2295}

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

Referenced by ATExecAddInherit(), and ATExecAttachPartition().

◆ FreeTriggerDesc()

void FreeTriggerDesc ( TriggerDesc *  trigdesc)

Definition at line 2145 of file trigger.c.

2146{
2147 Trigger *trigger;
2148 int i;
2149
2150 if (trigdesc == NULL)
2151 return;
2152
2153 trigger = trigdesc->triggers;
2154 for (i = 0; i < trigdesc->numtriggers; i++)
2155 {
2156 pfree(trigger->tgname);
2157 if (trigger->tgnattr > 0)
2158 pfree(trigger->tgattr);
2159 if (trigger->tgnargs > 0)
2160 {
2161 while (--(trigger->tgnargs) >= 0)
2162 pfree(trigger->tgargs[trigger->tgnargs]);
2163 pfree(trigger->tgargs);
2164 }
2165 if (trigger->tgqual)
2166 pfree(trigger->tgqual);
2167 if (trigger->tgoldtable)
2168 pfree(trigger->tgoldtable);
2169 if (trigger->tgnewtable)
2170 pfree(trigger->tgnewtable);
2171 trigger++;
2172 }
2173 pfree(trigdesc->triggers);
2174 pfree(trigdesc);
2175}

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

Referenced by RelationBuildTriggers(), and RelationDestroyRelation().

◆ get_trigger_oid()

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

Definition at line 1370 of file trigger.c.

1371{
1372 Relation tgrel;
1373 ScanKeyData skey[2];
1374 SysScanDesc tgscan;
1375 HeapTuple tup;
1376 Oid oid;
1377
1378 /*
1379 * Find the trigger, verify permissions, set up object address
1380 */
1381 tgrel = table_open(TriggerRelationId, AccessShareLock);
1382
1383 ScanKeyInit(&skey[0],
1384 Anum_pg_trigger_tgrelid,
1385 BTEqualStrategyNumber, F_OIDEQ,
1386 ObjectIdGetDatum(relid));
1387 ScanKeyInit(&skey[1],
1388 Anum_pg_trigger_tgname,
1389 BTEqualStrategyNumber, F_NAMEEQ,
1390 CStringGetDatum(trigname));
1391
1392 tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
1393 NULL, 2, skey);
1394
1395 tup = systable_getnext(tgscan);
1396
1397 if (!HeapTupleIsValid(tup))
1398 {
1399 if (!missing_ok)
1400 ereport(ERROR,
1401 (errcode(ERRCODE_UNDEFINED_OBJECT),
1402 errmsg("trigger \"%s\" for table \"%s\" does not exist",
1403 trigname, get_rel_name(relid))));
1404 oid = InvalidOid;
1405 }
1406 else
1407 {
1408 oid = ((Form_pg_trigger) GETSTRUCT(tup))->oid;
1409 }
1410
1411 systable_endscan(tgscan);
1412 table_close(tgrel, AccessShareLock);
1413 return oid;
1414}

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

Referenced by get_object_address_relobject().

◆ MakeTransitionCaptureState()

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

Definition at line 4968 of file trigger.c.

4969{
4970 TransitionCaptureState *state;
4971 bool need_old_upd,
4972 need_new_upd,
4973 need_old_del,
4974 need_new_ins;
4975 AfterTriggersTableData *table;
4976 MemoryContext oldcxt;
4977 ResourceOwner saveResourceOwner;
4978
4979 if (trigdesc == NULL)
4980 return NULL;
4981
4982 /* Detect which table(s) we need. */
4983 switch (cmdType)
4984 {
4985 case CMD_INSERT:
4986 need_old_upd = need_old_del = need_new_upd = false;
4987 need_new_ins = trigdesc->trig_insert_new_table;
4988 break;
4989 case CMD_UPDATE:
4990 need_old_upd = trigdesc->trig_update_old_table;
4991 need_new_upd = trigdesc->trig_update_new_table;
4992 need_old_del = need_new_ins = false;
4993 break;
4994 case CMD_DELETE:
4995 need_old_del = trigdesc->trig_delete_old_table;
4996 need_old_upd = need_new_upd = need_new_ins = false;
4997 break;
4998 case CMD_MERGE:
4999 need_old_upd = trigdesc->trig_update_old_table;
5000 need_new_upd = trigdesc->trig_update_new_table;
5001 need_old_del = trigdesc->trig_delete_old_table;
5002 need_new_ins = trigdesc->trig_insert_new_table;
5003 break;
5004 default:
5005 elog(ERROR, "unexpected CmdType: %d", (int) cmdType);
5006 /* keep compiler quiet */
5007 need_old_upd = need_new_upd = need_old_del = need_new_ins = false;
5008 break;
5009 }
5010 if (!need_old_upd && !need_new_upd && !need_new_ins && !need_old_del)
5011 return NULL;
5012
5013 /* Check state, like AfterTriggerSaveEvent. */
5014 if (afterTriggers.query_depth < 0)
5015 elog(ERROR, "MakeTransitionCaptureState() called outside of query");
5016
5017 /* Be sure we have enough space to record events at this query depth. */
5018 if (afterTriggers.query_depth >= afterTriggers.maxquerydepth)
5019 AfterTriggerEnlargeQueryState();
5020
5021 /*
5022 * Find or create an AfterTriggersTableData struct to hold the
5023 * tuplestore(s). If there's a matching struct but it's marked closed,
5024 * ignore it; we need a newer one.
5025 *
5026 * Note: the AfterTriggersTableData list, as well as the tuplestores, are
5027 * allocated in the current (sub)transaction's CurTransactionContext, and
5028 * the tuplestores are managed by the (sub)transaction's resource owner.
5029 * This is sufficient lifespan because we do not allow triggers using
5030 * transition tables to be deferrable; they will be fired during
5031 * AfterTriggerEndQuery, after which it's okay to delete the data.
5032 */
5033 table = GetAfterTriggersTableData(relid, cmdType);
5034
5035 /* Now create required tuplestore(s), if we don't have them already. */
5036 oldcxt = MemoryContextSwitchTo(CurTransactionContext);
5037 saveResourceOwner = CurrentResourceOwner;
5038 CurrentResourceOwner = CurTransactionResourceOwner;
5039
5040 if (need_old_upd && table->old_upd_tuplestore == NULL)
5041 table->old_upd_tuplestore = tuplestore_begin_heap(false, false, work_mem);
5042 if (need_new_upd && table->new_upd_tuplestore == NULL)
5043 table->new_upd_tuplestore = tuplestore_begin_heap(false, false, work_mem);
5044 if (need_old_del && table->old_del_tuplestore == NULL)
5045 table->old_del_tuplestore = tuplestore_begin_heap(false, false, work_mem);
5046 if (need_new_ins && table->new_ins_tuplestore == NULL)
5047 table->new_ins_tuplestore = tuplestore_begin_heap(false, false, work_mem);
5048
5049 CurrentResourceOwner = saveResourceOwner;
5050 MemoryContextSwitchTo(oldcxt);
5051
5052 /* Now build the TransitionCaptureState struct, in caller's context */
5053 state = (TransitionCaptureState *) palloc0(sizeof(TransitionCaptureState));
5054 state->tcs_delete_old_table = need_old_del;
5055 state->tcs_update_old_table = need_old_upd;
5056 state->tcs_update_new_table = need_new_upd;
5057 state->tcs_insert_new_table = need_new_ins;
5058 state->tcs_private = table;
5059
5060 return state;
5061}
work_mem
int work_mem
Definition: globals.c:131
palloc0
void * palloc0(Size size)
Definition: mcxt.c:1395
CurTransactionContext
MemoryContext CurTransactionContext
Definition: mcxt.c:172
CMD_MERGE
@ CMD_MERGE
Definition: nodes.h:279
table
static const struct lconv_member_info table[]
Definition: pg_localeconv_r.c:63
CurrentResourceOwner
ResourceOwner CurrentResourceOwner
Definition: resowner.c:173
CurTransactionResourceOwner
ResourceOwner CurTransactionResourceOwner
Definition: resowner.c:174
TriggerDesc::trig_update_new_table
bool trig_update_new_table
Definition: reltrigger.h:77
TriggerDesc::trig_insert_new_table
bool trig_insert_new_table
Definition: reltrigger.h:75
TriggerDesc::trig_delete_old_table
bool trig_delete_old_table
Definition: reltrigger.h:78
TriggerDesc::trig_update_old_table
bool trig_update_old_table
Definition: reltrigger.h:76
GetAfterTriggersTableData
static AfterTriggersTableData * GetAfterTriggersTableData(Oid relid, CmdType cmdType)
Definition: trigger.c:4882
AfterTriggerEnlargeQueryState
static void AfterTriggerEnlargeQueryState(void)
Definition: trigger.c:5623
tuplestore_begin_heap
Tuplestorestate * tuplestore_begin_heap(bool randomAccess, bool interXact, int maxKBytes)
Definition: tuplestore.c:330

References AfterTriggerEnlargeQueryState(), afterTriggers, CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_UPDATE, CurrentResourceOwner, CurTransactionContext, CurTransactionResourceOwner, elog, ERROR, GetAfterTriggersTableData(), AfterTriggersData::maxquerydepth, MemoryContextSwitchTo(), palloc0(), AfterTriggersData::query_depth, 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().

◆ RelationBuildTriggers()

void RelationBuildTriggers ( Relation  relation)

Definition at line 1861 of file trigger.c.

1862{
1863 TriggerDesc *trigdesc;
1864 int numtrigs;
1865 int maxtrigs;
1866 Trigger *triggers;
1867 Relation tgrel;
1868 ScanKeyData skey;
1869 SysScanDesc tgscan;
1870 HeapTuple htup;
1871 MemoryContext oldContext;
1872 int i;
1873
1874 /*
1875 * Allocate a working array to hold the triggers (the array is extended if
1876 * necessary)
1877 */
1878 maxtrigs = 16;
1879 triggers = (Trigger *) palloc(maxtrigs * sizeof(Trigger));
1880 numtrigs = 0;
1881
1882 /*
1883 * Note: since we scan the triggers using TriggerRelidNameIndexId, we will
1884 * be reading the triggers in name order, except possibly during
1885 * emergency-recovery operations (ie, IgnoreSystemIndexes). This in turn
1886 * ensures that triggers will be fired in name order.
1887 */
1888 ScanKeyInit(&skey,
1889 Anum_pg_trigger_tgrelid,
1890 BTEqualStrategyNumber, F_OIDEQ,
1891 ObjectIdGetDatum(RelationGetRelid(relation)));
1892
1893 tgrel = table_open(TriggerRelationId, AccessShareLock);
1894 tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
1895 NULL, 1, &skey);
1896
1897 while (HeapTupleIsValid(htup = systable_getnext(tgscan)))
1898 {
1899 Form_pg_trigger pg_trigger = (Form_pg_trigger) GETSTRUCT(htup);
1900 Trigger *build;
1901 Datum datum;
1902 bool isnull;
1903
1904 if (numtrigs >= maxtrigs)
1905 {
1906 maxtrigs *= 2;
1907 triggers = (Trigger *) repalloc(triggers, maxtrigs * sizeof(Trigger));
1908 }
1909 build = &(triggers[numtrigs]);
1910
1911 build->tgoid = pg_trigger->oid;
1912 build->tgname = DatumGetCString(DirectFunctionCall1(nameout,
1913 NameGetDatum(&pg_trigger->tgname)));
1914 build->tgfoid = pg_trigger->tgfoid;
1915 build->tgtype = pg_trigger->tgtype;
1916 build->tgenabled = pg_trigger->tgenabled;
1917 build->tgisinternal = pg_trigger->tgisinternal;
1918 build->tgisclone = OidIsValid(pg_trigger->tgparentid);
1919 build->tgconstrrelid = pg_trigger->tgconstrrelid;
1920 build->tgconstrindid = pg_trigger->tgconstrindid;
1921 build->tgconstraint = pg_trigger->tgconstraint;
1922 build->tgdeferrable = pg_trigger->tgdeferrable;
1923 build->tginitdeferred = pg_trigger->tginitdeferred;
1924 build->tgnargs = pg_trigger->tgnargs;
1925 /* tgattr is first var-width field, so OK to access directly */
1926 build->tgnattr = pg_trigger->tgattr.dim1;
1927 if (build->tgnattr > 0)
1928 {
1929 build->tgattr = (int16 *) palloc(build->tgnattr * sizeof(int16));
1930 memcpy(build->tgattr, &(pg_trigger->tgattr.values),
1931 build->tgnattr * sizeof(int16));
1932 }
1933 else
1934 build->tgattr = NULL;
1935 if (build->tgnargs > 0)
1936 {
1937 bytea *val;
1938 char *p;
1939
1940 val = DatumGetByteaPP(fastgetattr(htup,
1941 Anum_pg_trigger_tgargs,
1942 tgrel->rd_att, &isnull));
1943 if (isnull)
1944 elog(ERROR, "tgargs is null in trigger for relation \"%s\"",
1945 RelationGetRelationName(relation));
1946 p = (char *) VARDATA_ANY(val);
1947 build->tgargs = (char **) palloc(build->tgnargs * sizeof(char *));
1948 for (i = 0; i < build->tgnargs; i++)
1949 {
1950 build->tgargs[i] = pstrdup(p);
1951 p += strlen(p) + 1;
1952 }
1953 }
1954 else
1955 build->tgargs = NULL;
1956
1957 datum = fastgetattr(htup, Anum_pg_trigger_tgoldtable,
1958 tgrel->rd_att, &isnull);
1959 if (!isnull)
1960 build->tgoldtable =
1961 DatumGetCString(DirectFunctionCall1(nameout, datum));
1962 else
1963 build->tgoldtable = NULL;
1964
1965 datum = fastgetattr(htup, Anum_pg_trigger_tgnewtable,
1966 tgrel->rd_att, &isnull);
1967 if (!isnull)
1968 build->tgnewtable =
1969 DatumGetCString(DirectFunctionCall1(nameout, datum));
1970 else
1971 build->tgnewtable = NULL;
1972
1973 datum = fastgetattr(htup, Anum_pg_trigger_tgqual,
1974 tgrel->rd_att, &isnull);
1975 if (!isnull)
1976 build->tgqual = TextDatumGetCString(datum);
1977 else
1978 build->tgqual = NULL;
1979
1980 numtrigs++;
1981 }
1982
1983 systable_endscan(tgscan);
1984 table_close(tgrel, AccessShareLock);
1985
1986 /* There might not be any triggers */
1987 if (numtrigs == 0)
1988 {
1989 pfree(triggers);
1990 return;
1991 }
1992
1993 /* Build trigdesc */
1994 trigdesc = (TriggerDesc *) palloc0(sizeof(TriggerDesc));
1995 trigdesc->triggers = triggers;
1996 trigdesc->numtriggers = numtrigs;
1997 for (i = 0; i < numtrigs; i++)
1998 SetTriggerFlags(trigdesc, &(triggers[i]));
1999
2000 /* Copy completed trigdesc into cache storage */
2001 oldContext = MemoryContextSwitchTo(CacheMemoryContext);
2002 relation->trigdesc = CopyTriggerDesc(trigdesc);
2003 MemoryContextSwitchTo(oldContext);
2004
2005 /* Release working memory */
2006 FreeTriggerDesc(trigdesc);
2007}
TextDatumGetCString
#define TextDatumGetCString(d)
Definition: builtins.h:98
DatumGetByteaPP
#define DatumGetByteaPP(X)
Definition: fmgr.h:291
fastgetattr
static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:861
val
long val
Definition: informix.c:689
CacheMemoryContext
MemoryContext CacheMemoryContext
Definition: mcxt.c:169
nameout
Datum nameout(PG_FUNCTION_ARGS)
Definition: name.c:71
DatumGetCString
static char * DatumGetCString(Datum X)
Definition: postgres.h:345
NameGetDatum
static Datum NameGetDatum(const NameData *X)
Definition: postgres.h:383
RelationData::trigdesc
TriggerDesc * trigdesc
Definition: rel.h:117
Trigger::tgenabled
char tgenabled
Definition: reltrigger.h:30
Trigger::tgoid
Oid tgoid
Definition: reltrigger.h:25
Trigger::tgconstrindid
Oid tgconstrindid
Definition: reltrigger.h:34
Trigger::tgconstraint
Oid tgconstraint
Definition: reltrigger.h:35
Trigger::tgconstrrelid
Oid tgconstrrelid
Definition: reltrigger.h:33
Trigger::tgfoid
Oid tgfoid
Definition: reltrigger.h:28
Trigger::tgdeferrable
bool tgdeferrable
Definition: reltrigger.h:36
Trigger::tginitdeferred
bool tginitdeferred
Definition: reltrigger.h:37
Trigger::tgisinternal
bool tgisinternal
Definition: reltrigger.h:31
varlena
Definition: c.h:697
FreeTriggerDesc
void FreeTriggerDesc(TriggerDesc *trigdesc)
Definition: trigger.c:2145
SetTriggerFlags
static void SetTriggerFlags(TriggerDesc *trigdesc, Trigger *trigger)
Definition: trigger.c:2013
CopyTriggerDesc
TriggerDesc * CopyTriggerDesc(TriggerDesc *trigdesc)
Definition: trigger.c:2090
VARDATA_ANY
static char * VARDATA_ANY(const void *PTR)
Definition: varatt.h:486

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

Referenced by RelationBuildDesc(), and RelationCacheInitializePhase3().

◆ RemoveTriggerById()

void RemoveTriggerById ( Oid  trigOid)

Definition at line 1291 of file trigger.c.

1292{
1293 Relation tgrel;
1294 SysScanDesc tgscan;
1295 ScanKeyData skey[1];
1296 HeapTuple tup;
1297 Oid relid;
1298 Relation rel;
1299
1300 tgrel = table_open(TriggerRelationId, RowExclusiveLock);
1301
1302 /*
1303 * Find the trigger to delete.
1304 */
1305 ScanKeyInit(&skey[0],
1306 Anum_pg_trigger_oid,
1307 BTEqualStrategyNumber, F_OIDEQ,
1308 ObjectIdGetDatum(trigOid));
1309
1310 tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,
1311 NULL, 1, skey);
1312
1313 tup = systable_getnext(tgscan);
1314 if (!HeapTupleIsValid(tup))
1315 elog(ERROR, "could not find tuple for trigger %u", trigOid);
1316
1317 /*
1318 * Open and exclusive-lock the relation the trigger belongs to.
1319 */
1320 relid = ((Form_pg_trigger) GETSTRUCT(tup))->tgrelid;
1321
1322 rel = table_open(relid, AccessExclusiveLock);
1323
1324 if (rel->rd_rel->relkind != RELKIND_RELATION &&
1325 rel->rd_rel->relkind != RELKIND_VIEW &&
1326 rel->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
1327 rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
1328 ereport(ERROR,
1329 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1330 errmsg("relation \"%s\" cannot have triggers",
1331 RelationGetRelationName(rel)),
1332 errdetail_relkind_not_supported(rel->rd_rel->relkind)));
1333
1334 if (!allowSystemTableMods && IsSystemRelation(rel))
1335 ereport(ERROR,
1336 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1337 errmsg("permission denied: \"%s\" is a system catalog",
1338 RelationGetRelationName(rel))));
1339
1340 /*
1341 * Delete the pg_trigger tuple.
1342 */
1343 CatalogTupleDelete(tgrel, &tup->t_self);
1344
1345 systable_endscan(tgscan);
1346 table_close(tgrel, RowExclusiveLock);
1347
1348 /*
1349 * We do not bother to try to determine whether any other triggers remain,
1350 * which would be needed in order to decide whether it's safe to clear the
1351 * relation's relhastriggers. (In any case, there might be a concurrent
1352 * process adding new triggers.) Instead, just force a relcache inval to
1353 * make other backends (and this one too!) rebuild their relcache entries.
1354 * There's no great harm in leaving relhastriggers true even if there are
1355 * no triggers left.
1356 */
1357 CacheInvalidateRelcache(rel);
1358
1359 /* Keep lock on trigger's rel until end of xact */
1360 table_close(rel, NoLock);
1361}
CatalogTupleDelete
void CatalogTupleDelete(Relation heapRel, const ItemPointerData *tid)
Definition: indexing.c:365
AccessExclusiveLock
#define AccessExclusiveLock
Definition: lockdefs.h:43

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

Referenced by doDeletion().

◆ renametrig()

ObjectAddress renametrig ( RenameStmt *  stmt)

Definition at line 1467 of file trigger.c.

1468{
1469 Oid tgoid;
1470 Relation targetrel;
1471 Relation tgrel;
1472 HeapTuple tuple;
1473 SysScanDesc tgscan;
1474 ScanKeyData key[2];
1475 Oid relid;
1476 ObjectAddress address;
1477
1478 /*
1479 * Look up name, check permissions, and acquire lock (which we will NOT
1480 * release until end of transaction).
1481 */
1482 relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
1483 0,
1484 RangeVarCallbackForRenameTrigger,
1485 NULL);
1486
1487 /* Have lock already, so just need to build relcache entry. */
1488 targetrel = relation_open(relid, NoLock);
1489
1490 /*
1491 * On partitioned tables, this operation recurses to partitions. Lock all
1492 * tables upfront.
1493 */
1494 if (targetrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
1495 (void) find_all_inheritors(relid, AccessExclusiveLock, NULL);
1496
1497 tgrel = table_open(TriggerRelationId, RowExclusiveLock);
1498
1499 /*
1500 * Search for the trigger to modify.
1501 */
1502 ScanKeyInit(&key[0],
1503 Anum_pg_trigger_tgrelid,
1504 BTEqualStrategyNumber, F_OIDEQ,
1505 ObjectIdGetDatum(relid));
1506 ScanKeyInit(&key[1],
1507 Anum_pg_trigger_tgname,
1508 BTEqualStrategyNumber, F_NAMEEQ,
1509 PointerGetDatum(stmt->subname));
1510 tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
1511 NULL, 2, key);
1512 if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
1513 {
1514 Form_pg_trigger trigform;
1515
1516 trigform = (Form_pg_trigger) GETSTRUCT(tuple);
1517 tgoid = trigform->oid;
1518
1519 /*
1520 * If the trigger descends from a trigger on a parent partitioned
1521 * table, reject the rename. We don't allow a trigger in a partition
1522 * to differ in name from that of its parent: that would lead to an
1523 * inconsistency that pg_dump would not reproduce.
1524 */
1525 if (OidIsValid(trigform->tgparentid))
1526 ereport(ERROR,
1527 errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1528 errmsg("cannot rename trigger \"%s\" on table \"%s\"",
1529 stmt->subname, RelationGetRelationName(targetrel)),
1530 errhint("Rename the trigger on the partitioned table \"%s\" instead.",
1531 get_rel_name(get_partition_parent(relid, false))));
1532
1533
1534 /* Rename the trigger on this relation ... */
1535 renametrig_internal(tgrel, targetrel, tuple, stmt->newname,
1536 stmt->subname);
1537
1538 /* ... and if it is partitioned, recurse to its partitions */
1539 if (targetrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
1540 {
1541 PartitionDesc partdesc = RelationGetPartitionDesc(targetrel, true);
1542
1543 for (int i = 0; i < partdesc->nparts; i++)
1544 {
1545 Oid partitionId = partdesc->oids[i];
1546
1547 renametrig_partition(tgrel, partitionId, trigform->oid,
1548 stmt->newname, stmt->subname);
1549 }
1550 }
1551 }
1552 else
1553 {
1554 ereport(ERROR,
1555 (errcode(ERRCODE_UNDEFINED_OBJECT),
1556 errmsg("trigger \"%s\" for table \"%s\" does not exist",
1557 stmt->subname, RelationGetRelationName(targetrel))));
1558 }
1559
1560 ObjectAddressSet(address, TriggerRelationId, tgoid);
1561
1562 systable_endscan(tgscan);
1563
1564 table_close(tgrel, RowExclusiveLock);
1565
1566 /*
1567 * Close rel, but keep exclusive lock!
1568 */
1569 relation_close(targetrel, NoLock);
1570
1571 return address;
1572}
RangeVarGetRelidExtended
Oid RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Definition: namespace.c:440
get_partition_parent
Oid get_partition_parent(Oid relid, bool even_if_detached)
Definition: partition.c:53
relation_close
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
renametrig_internal
static void renametrig_internal(Relation tgrel, Relation targetrel, HeapTuple trigtup, const char *newname, const char *expected_name)
Definition: trigger.c:1582
RangeVarCallbackForRenameTrigger
static void RangeVarCallbackForRenameTrigger(const RangeVar *rv, Oid relid, Oid oldrelid, void *arg)
Definition: trigger.c:1420
renametrig_partition
static void renametrig_partition(Relation tgrel, Oid partitionId, Oid parentTriggerOid, const char *newname, const char *expected_name)
Definition: trigger.c:1653

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

Referenced by ExecRenameStmt().

◆ RI_FKey_fk_upd_check_required()

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

Definition at line 1416 of file ri_triggers.c.

1418{
1419 const RI_ConstraintInfo *riinfo;
1420 int ri_nullcheck;
1421
1422 /*
1423 * AfterTriggerSaveEvent() handles things such that this function is never
1424 * called for partitioned tables.
1425 */
1426 Assert(fk_rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE);
1427
1428 riinfo = ri_FetchConstraintInfo(trigger, fk_rel, false);
1429
1430 ri_nullcheck = ri_NullCheck(RelationGetDescr(fk_rel), newslot, riinfo, false);
1431
1432 /*
1433 * If all new key values are NULL, the row satisfies the constraint, so no
1434 * check is needed.
1435 */
1436 if (ri_nullcheck == RI_KEYS_ALL_NULL)
1437 return false;
1438
1439 /*
1440 * If some new key values are NULL, the behavior depends on the match
1441 * type.
1442 */
1443 else if (ri_nullcheck == RI_KEYS_SOME_NULL)
1444 {
1445 switch (riinfo->confmatchtype)
1446 {
1447 case FKCONSTR_MATCH_SIMPLE:
1448
1449 /*
1450 * If any new key value is NULL, the row must satisfy the
1451 * constraint, so no check is needed.
1452 */
1453 return false;
1454
1455 case FKCONSTR_MATCH_PARTIAL:
1456
1457 /*
1458 * Don't know, must run full check.
1459 */
1460 break;
1461
1462 case FKCONSTR_MATCH_FULL:
1463
1464 /*
1465 * If some new key values are NULL, the row fails the
1466 * constraint. We must not throw error here, because the row
1467 * might get invalidated before the constraint is to be
1468 * checked, but we should queue the event to apply the check
1469 * later.
1470 */
1471 return true;
1472 }
1473 }
1474
1475 /*
1476 * Continues here for no new key values are NULL, or we couldn't decide
1477 * yet.
1478 */
1479
1480 /*
1481 * If the original row was inserted by our own transaction, we must fire
1482 * the trigger whether or not the keys are equal. This is because our
1483 * UPDATE will invalidate the INSERT so that the INSERT RI trigger will
1484 * not do anything; so we had better do the UPDATE check. (We could skip
1485 * this if we knew the INSERT trigger already fired, but there is no easy
1486 * way to know that.)
1487 */
1488 if (slot_is_current_xact_tuple(oldslot))
1489 return true;
1490
1491 /* If all old and new key values are equal, no check is needed */
1492 if (ri_KeysEqual(fk_rel, oldslot, newslot, riinfo, false))
1493 return false;
1494
1495 /* Else we need to fire the trigger. */
1496 return true;
1497}
FKCONSTR_MATCH_SIMPLE
#define FKCONSTR_MATCH_SIMPLE
Definition: parsenodes.h:2828
FKCONSTR_MATCH_PARTIAL
#define FKCONSTR_MATCH_PARTIAL
Definition: parsenodes.h:2827
FKCONSTR_MATCH_FULL
#define FKCONSTR_MATCH_FULL
Definition: parsenodes.h:2826
RI_KEYS_SOME_NULL
#define RI_KEYS_SOME_NULL
Definition: ri_triggers.c:64
ri_NullCheck
static int ri_NullCheck(TupleDesc tupDesc, TupleTableSlot *slot, const RI_ConstraintInfo *riinfo, bool rel_is_pk)
Definition: ri_triggers.c:2821
ri_KeysEqual
static bool ri_KeysEqual(Relation rel, TupleTableSlot *oldslot, TupleTableSlot *newslot, const RI_ConstraintInfo *riinfo, bool rel_is_pk)
Definition: ri_triggers.c:2983
RI_KEYS_ALL_NULL
#define RI_KEYS_ALL_NULL
Definition: ri_triggers.c:63
ri_FetchConstraintInfo
static const RI_ConstraintInfo * ri_FetchConstraintInfo(Trigger *trigger, Relation trig_rel, bool rel_is_pk)
Definition: ri_triggers.c:2212
RI_ConstraintInfo
Definition: ri_triggers.c:105
RI_ConstraintInfo::confmatchtype
char confmatchtype
Definition: ri_triggers.c:121
slot_is_current_xact_tuple
static bool slot_is_current_xact_tuple(TupleTableSlot *slot)
Definition: tuptable.h:448

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

Referenced by AfterTriggerSaveEvent().

◆ RI_FKey_pk_upd_check_required()

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

Definition at line 1384 of file ri_triggers.c.

1386{
1387 const RI_ConstraintInfo *riinfo;
1388
1389 riinfo = ri_FetchConstraintInfo(trigger, pk_rel, true);
1390
1391 /*
1392 * If any old key value is NULL, the row could not have been referenced by
1393 * an FK row, so no check is needed.
1394 */
1395 if (ri_NullCheck(RelationGetDescr(pk_rel), oldslot, riinfo, true) != RI_KEYS_NONE_NULL)
1396 return false;
1397
1398 /* If all old and new key values are equal, no check is needed */
1399 if (newslot && ri_KeysEqual(pk_rel, oldslot, newslot, riinfo, true))
1400 return false;
1401
1402 /* Else we need to fire the trigger. */
1403 return true;
1404}
RI_KEYS_NONE_NULL
#define RI_KEYS_NONE_NULL
Definition: ri_triggers.c:65

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

Referenced by AfterTriggerSaveEvent().

◆ RI_FKey_trigger_type()

int RI_FKey_trigger_type ( Oid  tgfoid)

Definition at line 3208 of file ri_triggers.c.

3209{
3210 switch (tgfoid)
3211 {
3212 case F_RI_FKEY_CASCADE_DEL:
3213 case F_RI_FKEY_CASCADE_UPD:
3214 case F_RI_FKEY_RESTRICT_DEL:
3215 case F_RI_FKEY_RESTRICT_UPD:
3216 case F_RI_FKEY_SETNULL_DEL:
3217 case F_RI_FKEY_SETNULL_UPD:
3218 case F_RI_FKEY_SETDEFAULT_DEL:
3219 case F_RI_FKEY_SETDEFAULT_UPD:
3220 case F_RI_FKEY_NOACTION_DEL:
3221 case F_RI_FKEY_NOACTION_UPD:
3222 return RI_TRIGGER_PK;
3223
3224 case F_RI_FKEY_CHECK_INS:
3225 case F_RI_FKEY_CHECK_UPD:
3226 return RI_TRIGGER_FK;
3227 }
3228
3229 return RI_TRIGGER_NONE;
3230}
RI_TRIGGER_FK
#define RI_TRIGGER_FK
Definition: trigger.h:285
RI_TRIGGER_NONE
#define RI_TRIGGER_NONE
Definition: trigger.h:286
RI_TRIGGER_PK
#define RI_TRIGGER_PK
Definition: trigger.h:284

References RI_TRIGGER_FK, RI_TRIGGER_NONE, and RI_TRIGGER_PK.

Referenced by AfterTriggerSaveEvent(), ExecCrossPartitionUpdateForeignKey(), GetForeignKeyActionTriggers(), and GetForeignKeyCheckTriggers().

◆ RI_Initial_Check()

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

Definition at line 1517 of file ri_triggers.c.

1518{
1519 const RI_ConstraintInfo *riinfo;
1520 StringInfoData querybuf;
1521 char pkrelname[MAX_QUOTED_REL_NAME_LEN];
1522 char fkrelname[MAX_QUOTED_REL_NAME_LEN];
1523 char pkattname[MAX_QUOTED_NAME_LEN + 3];
1524 char fkattname[MAX_QUOTED_NAME_LEN + 3];
1525 RangeTblEntry *rte;
1526 RTEPermissionInfo *pk_perminfo;
1527 RTEPermissionInfo *fk_perminfo;
1528 List *rtes = NIL;
1529 List *perminfos = NIL;
1530 const char *sep;
1531 const char *fk_only;
1532 const char *pk_only;
1533 int save_nestlevel;
1534 char workmembuf[32];
1535 int spi_result;
1536 SPIPlanPtr qplan;
1537
1538 riinfo = ri_FetchConstraintInfo(trigger, fk_rel, false);
1539
1540 /*
1541 * Check to make sure current user has enough permissions to do the test
1542 * query. (If not, caller can fall back to the trigger method, which
1543 * works because it changes user IDs on the fly.)
1544 *
1545 * XXX are there any other show-stopper conditions to check?
1546 */
1547 pk_perminfo = makeNode(RTEPermissionInfo);
1548 pk_perminfo->relid = RelationGetRelid(pk_rel);
1549 pk_perminfo->requiredPerms = ACL_SELECT;
1550 perminfos = lappend(perminfos, pk_perminfo);
1551 rte = makeNode(RangeTblEntry);
1552 rte->rtekind = RTE_RELATION;
1553 rte->relid = RelationGetRelid(pk_rel);
1554 rte->relkind = pk_rel->rd_rel->relkind;
1555 rte->rellockmode = AccessShareLock;
1556 rte->perminfoindex = list_length(perminfos);
1557 rtes = lappend(rtes, rte);
1558
1559 fk_perminfo = makeNode(RTEPermissionInfo);
1560 fk_perminfo->relid = RelationGetRelid(fk_rel);
1561 fk_perminfo->requiredPerms = ACL_SELECT;
1562 perminfos = lappend(perminfos, fk_perminfo);
1563 rte = makeNode(RangeTblEntry);
1564 rte->rtekind = RTE_RELATION;
1565 rte->relid = RelationGetRelid(fk_rel);
1566 rte->relkind = fk_rel->rd_rel->relkind;
1567 rte->rellockmode = AccessShareLock;
1568 rte->perminfoindex = list_length(perminfos);
1569 rtes = lappend(rtes, rte);
1570
1571 for (int i = 0; i < riinfo->nkeys; i++)
1572 {
1573 int attno;
1574
1575 attno = riinfo->pk_attnums[i] - FirstLowInvalidHeapAttributeNumber;
1576 pk_perminfo->selectedCols = bms_add_member(pk_perminfo->selectedCols, attno);
1577
1578 attno = riinfo->fk_attnums[i] - FirstLowInvalidHeapAttributeNumber;
1579 fk_perminfo->selectedCols = bms_add_member(fk_perminfo->selectedCols, attno);
1580 }
1581
1582 if (!ExecCheckPermissions(rtes, perminfos, false))
1583 return false;
1584
1585 /*
1586 * Also punt if RLS is enabled on either table unless this role has the
1587 * bypassrls right or is the table owner of the table(s) involved which
1588 * have RLS enabled.
1589 */
1590 if (!has_bypassrls_privilege(GetUserId()) &&
1591 ((pk_rel->rd_rel->relrowsecurity &&
1592 !object_ownercheck(RelationRelationId, RelationGetRelid(pk_rel),
1593 GetUserId())) ||
1594 (fk_rel->rd_rel->relrowsecurity &&
1595 !object_ownercheck(RelationRelationId, RelationGetRelid(fk_rel),
1596 GetUserId()))))
1597 return false;
1598
1599 /*----------
1600 * The query string built is:
1601 * SELECT fk.keycols FROM [ONLY] relname fk
1602 * LEFT OUTER JOIN [ONLY] pkrelname pk
1603 * ON (pk.pkkeycol1=fk.keycol1 [AND ...])
1604 * WHERE pk.pkkeycol1 IS NULL AND
1605 * For MATCH SIMPLE:
1606 * (fk.keycol1 IS NOT NULL [AND ...])
1607 * For MATCH FULL:
1608 * (fk.keycol1 IS NOT NULL [OR ...])
1609 *
1610 * We attach COLLATE clauses to the operators when comparing columns
1611 * that have different collations.
1612 *----------
1613 */
1614 initStringInfo(&querybuf);
1615 appendStringInfoString(&querybuf, "SELECT ");
1616 sep = "";
1617 for (int i = 0; i < riinfo->nkeys; i++)
1618 {
1619 quoteOneName(fkattname,
1620 RIAttName(fk_rel, riinfo->fk_attnums[i]));
1621 appendStringInfo(&querybuf, "%sfk.%s", sep, fkattname);
1622 sep = ", ";
1623 }
1624
1625 quoteRelationName(pkrelname, pk_rel);
1626 quoteRelationName(fkrelname, fk_rel);
1627 fk_only = fk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
1628 "" : "ONLY ";
1629 pk_only = pk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
1630 "" : "ONLY ";
1631 appendStringInfo(&querybuf,
1632 " FROM %s%s fk LEFT OUTER JOIN %s%s pk ON",
1633 fk_only, fkrelname, pk_only, pkrelname);
1634
1635 strcpy(pkattname, "pk.");
1636 strcpy(fkattname, "fk.");
1637 sep = "(";
1638 for (int i = 0; i < riinfo->nkeys; i++)
1639 {
1640 Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
1641 Oid fk_type = RIAttType(fk_rel, riinfo->fk_attnums[i]);
1642 Oid pk_coll = RIAttCollation(pk_rel, riinfo->pk_attnums[i]);
1643 Oid fk_coll = RIAttCollation(fk_rel, riinfo->fk_attnums[i]);
1644
1645 quoteOneName(pkattname + 3,
1646 RIAttName(pk_rel, riinfo->pk_attnums[i]));
1647 quoteOneName(fkattname + 3,
1648 RIAttName(fk_rel, riinfo->fk_attnums[i]));
1649 ri_GenerateQual(&querybuf, sep,
1650 pkattname, pk_type,
1651 riinfo->pf_eq_oprs[i],
1652 fkattname, fk_type);
1653 if (pk_coll != fk_coll)
1654 ri_GenerateQualCollation(&querybuf, pk_coll);
1655 sep = "AND";
1656 }
1657
1658 /*
1659 * It's sufficient to test any one pk attribute for null to detect a join
1660 * failure.
1661 */
1662 quoteOneName(pkattname, RIAttName(pk_rel, riinfo->pk_attnums[0]));
1663 appendStringInfo(&querybuf, ") WHERE pk.%s IS NULL AND (", pkattname);
1664
1665 sep = "";
1666 for (int i = 0; i < riinfo->nkeys; i++)
1667 {
1668 quoteOneName(fkattname, RIAttName(fk_rel, riinfo->fk_attnums[i]));
1669 appendStringInfo(&querybuf,
1670 "%sfk.%s IS NOT NULL",
1671 sep, fkattname);
1672 switch (riinfo->confmatchtype)
1673 {
1674 case FKCONSTR_MATCH_SIMPLE:
1675 sep = " AND ";
1676 break;
1677 case FKCONSTR_MATCH_FULL:
1678 sep = " OR ";
1679 break;
1680 }
1681 }
1682 appendStringInfoChar(&querybuf, ')');
1683
1684 /*
1685 * Temporarily increase work_mem so that the check query can be executed
1686 * more efficiently. It seems okay to do this because the query is simple
1687 * enough to not use a multiple of work_mem, and one typically would not
1688 * have many large foreign-key validations happening concurrently. So
1689 * this seems to meet the criteria for being considered a "maintenance"
1690 * operation, and accordingly we use maintenance_work_mem. However, we
1691 * must also set hash_mem_multiplier to 1, since it is surely not okay to
1692 * let that get applied to the maintenance_work_mem value.
1693 *
1694 * We use the equivalent of a function SET option to allow the setting to
1695 * persist for exactly the duration of the check query. guc.c also takes
1696 * care of undoing the setting on error.
1697 */
1698 save_nestlevel = NewGUCNestLevel();
1699
1700 snprintf(workmembuf, sizeof(workmembuf), "%d", maintenance_work_mem);
1701 (void) set_config_option("work_mem", workmembuf,
1702 PGC_USERSET, PGC_S_SESSION,
1703 GUC_ACTION_SAVE, true, 0, false);
1704 (void) set_config_option("hash_mem_multiplier", "1",
1705 PGC_USERSET, PGC_S_SESSION,
1706 GUC_ACTION_SAVE, true, 0, false);
1707
1708 SPI_connect();
1709
1710 /*
1711 * Generate the plan. We don't need to cache it, and there are no
1712 * arguments to the plan.
1713 */
1714 qplan = SPI_prepare(querybuf.data, 0, NULL);
1715
1716 if (qplan == NULL)
1717 elog(ERROR, "SPI_prepare returned %s for %s",
1718 SPI_result_code_string(SPI_result), querybuf.data);
1719
1720 /*
1721 * Run the plan. For safety we force a current snapshot to be used. (In
1722 * transaction-snapshot mode, this arguably violates transaction isolation
1723 * rules, but we really haven't got much choice.) We don't need to
1724 * register the snapshot, because SPI_execute_snapshot will see to it. We
1725 * need at most one tuple returned, so pass limit = 1.
1726 */
1727 spi_result = SPI_execute_snapshot(qplan,
1728 NULL, NULL,
1729 GetLatestSnapshot(),
1730 InvalidSnapshot,
1731 true, false, 1);
1732
1733 /* Check result */
1734 if (spi_result != SPI_OK_SELECT)
1735 elog(ERROR, "SPI_execute_snapshot returned %s", SPI_result_code_string(spi_result));
1736
1737 /* Did we find a tuple violating the constraint? */
1738 if (SPI_processed > 0)
1739 {
1740 TupleTableSlot *slot;
1741 HeapTuple tuple = SPI_tuptable->vals[0];
1742 TupleDesc tupdesc = SPI_tuptable->tupdesc;
1743 RI_ConstraintInfo fake_riinfo;
1744
1745 slot = MakeSingleTupleTableSlot(tupdesc, &TTSOpsVirtual);
1746
1747 heap_deform_tuple(tuple, tupdesc,
1748 slot->tts_values, slot->tts_isnull);
1749 ExecStoreVirtualTuple(slot);
1750
1751 /*
1752 * The columns to look at in the result tuple are 1..N, not whatever
1753 * they are in the fk_rel. Hack up riinfo so that the subroutines
1754 * called here will behave properly.
1755 *
1756 * In addition to this, we have to pass the correct tupdesc to
1757 * ri_ReportViolation, overriding its normal habit of using the pk_rel
1758 * or fk_rel's tupdesc.
1759 */
1760 memcpy(&fake_riinfo, riinfo, sizeof(RI_ConstraintInfo));
1761 for (int i = 0; i < fake_riinfo.nkeys; i++)
1762 fake_riinfo.fk_attnums[i] = i + 1;
1763
1764 /*
1765 * If it's MATCH FULL, and there are any nulls in the FK keys,
1766 * complain about that rather than the lack of a match. MATCH FULL
1767 * disallows partially-null FK rows.
1768 */
1769 if (fake_riinfo.confmatchtype == FKCONSTR_MATCH_FULL &&
1770 ri_NullCheck(tupdesc, slot, &fake_riinfo, false) != RI_KEYS_NONE_NULL)
1771 ereport(ERROR,
1772 (errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
1773 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
1774 RelationGetRelationName(fk_rel),
1775 NameStr(fake_riinfo.conname)),
1776 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
1777 errtableconstraint(fk_rel,
1778 NameStr(fake_riinfo.conname))));
1779
1780 /*
1781 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
1782 * query, which isn't true, but will cause it to use
1783 * fake_riinfo.fk_attnums as we need.
1784 */
1785 ri_ReportViolation(&fake_riinfo,
1786 pk_rel, fk_rel,
1787 slot, tupdesc,
1788 RI_PLAN_CHECK_LOOKUPPK, false, false);
1789
1790 ExecDropSingleTupleTableSlot(slot);
1791 }
1792
1793 if (SPI_finish() != SPI_OK_FINISH)
1794 elog(ERROR, "SPI_finish failed");
1795
1796 /*
1797 * Restore work_mem and hash_mem_multiplier.
1798 */
1799 AtEOXact_GUC(true, save_nestlevel);
1800
1801 return true;
1802}
has_bypassrls_privilege
bool has_bypassrls_privilege(Oid roleid)
Definition: aclchk.c:4186
object_ownercheck
bool object_ownercheck(Oid classid, Oid objectid, Oid roleid)
Definition: aclchk.c:4088
bms_add_member
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
ExecCheckPermissions
bool ExecCheckPermissions(List *rangeTable, List *rteperminfos, bool ereport_on_violation)
Definition: execMain.c:582
MakeSingleTupleTableSlot
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1427
TTSOpsVirtual
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:84
ExecDropSingleTupleTableSlot
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
Definition: execTuples.c:1443
ExecStoreVirtualTuple
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1741
maintenance_work_mem
int maintenance_work_mem
Definition: globals.c:133
NewGUCNestLevel
int NewGUCNestLevel(void)
Definition: guc.c:2110
AtEOXact_GUC
void AtEOXact_GUC(bool isCommit, int nestLevel)
Definition: guc.c:2137
set_config_option
int set_config_option(const char *name, const char *value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3216
GUC_ACTION_SAVE
@ GUC_ACTION_SAVE
Definition: guc.h:205
PGC_S_SESSION
@ PGC_S_SESSION
Definition: guc.h:126
PGC_USERSET
@ PGC_USERSET
Definition: guc.h:79
heap_deform_tuple
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1346
if
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
lappend
List * lappend(List *list, void *datum)
Definition: list.c:339
makeNode
#define makeNode(_type_)
Definition: nodes.h:161
RTE_RELATION
@ RTE_RELATION
Definition: parsenodes.h:1043
ACL_SELECT
#define ACL_SELECT
Definition: parsenodes.h:77
errtableconstraint
int errtableconstraint(Relation rel, const char *conname)
Definition: relcache.c:6103
ri_ReportViolation
static pg_noreturn void ri_ReportViolation(const RI_ConstraintInfo *riinfo, Relation pk_rel, Relation fk_rel, TupleTableSlot *violatorslot, TupleDesc tupdesc, int queryno, bool is_restrict, bool partgone)
Definition: ri_triggers.c:2649
quoteOneName
static void quoteOneName(char *buffer, const char *name)
Definition: ri_triggers.c:2029
RIAttType
#define RIAttType(rel, attnum)
Definition: ri_triggers.c:87
ri_GenerateQualCollation
static void ri_GenerateQualCollation(StringInfo buf, Oid collation)
Definition: ri_triggers.c:2093
MAX_QUOTED_REL_NAME_LEN
#define MAX_QUOTED_REL_NAME_LEN
Definition: ri_triggers.c:84
quoteRelationName
static void quoteRelationName(char *buffer, Relation rel)
Definition: ri_triggers.c:2049
ri_GenerateQual
static void ri_GenerateQual(StringInfo buf, const char *sep, const char *leftop, Oid leftoptype, Oid opoid, const char *rightop, Oid rightoptype)
Definition: ri_triggers.c:2066
RIAttCollation
#define RIAttCollation(rel, attnum)
Definition: ri_triggers.c:88
RI_PLAN_CHECK_LOOKUPPK
#define RI_PLAN_CHECK_LOOKUPPK
Definition: ri_triggers.c:69
MAX_QUOTED_NAME_LEN
#define MAX_QUOTED_NAME_LEN
Definition: ri_triggers.c:83
RIAttName
#define RIAttName(rel, attnum)
Definition: ri_triggers.c:86
GetLatestSnapshot
Snapshot GetLatestSnapshot(void)
Definition: snapmgr.c:353
InvalidSnapshot
#define InvalidSnapshot
Definition: snapshot.h:119
SPI_processed
uint64 SPI_processed
Definition: spi.c:44
SPI_result_code_string
const char * SPI_result_code_string(int code)
Definition: spi.c:1972
SPI_tuptable
SPITupleTable * SPI_tuptable
Definition: spi.c:45
SPI_connect
int SPI_connect(void)
Definition: spi.c:94
SPI_result
int SPI_result
Definition: spi.c:46
SPI_finish
int SPI_finish(void)
Definition: spi.c:182
SPI_execute_snapshot
int SPI_execute_snapshot(SPIPlanPtr plan, const Datum *Values, const char *Nulls, Snapshot snapshot, Snapshot crosscheck_snapshot, bool read_only, bool fire_triggers, long tcount)
Definition: spi.c:773
SPI_prepare
SPIPlanPtr SPI_prepare(const char *src, int nargs, Oid *argtypes)
Definition: spi.c:860
SPI_OK_FINISH
#define SPI_OK_FINISH
Definition: spi.h:83
SPI_OK_SELECT
#define SPI_OK_SELECT
Definition: spi.h:86
appendStringInfo
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:145
appendStringInfoString
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:230
appendStringInfoChar
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:242
initStringInfo
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
RI_ConstraintInfo::pk_attnums
int16 pk_attnums[RI_MAX_NUMKEYS]
Definition: ri_triggers.c:124
RI_ConstraintInfo::conname
NameData conname
Definition: ri_triggers.c:112
RI_ConstraintInfo::fk_attnums
int16 fk_attnums[RI_MAX_NUMKEYS]
Definition: ri_triggers.c:125
RI_ConstraintInfo::pf_eq_oprs
Oid pf_eq_oprs[RI_MAX_NUMKEYS]
Definition: ri_triggers.c:126
RI_ConstraintInfo::nkeys
int nkeys
Definition: ri_triggers.c:123
RTEPermissionInfo::selectedCols
Bitmapset * selectedCols
Definition: parsenodes.h:1324
RTEPermissionInfo::requiredPerms
AclMode requiredPerms
Definition: parsenodes.h:1322
RangeTblEntry::rtekind
RTEKind rtekind
Definition: parsenodes.h:1078
SPITupleTable::tupdesc
TupleDesc tupdesc
Definition: spi.h:25
SPITupleTable::vals
HeapTuple * vals
Definition: spi.h:26
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:126
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:124
_SPI_plan
Definition: spi_priv.h:91
FirstLowInvalidHeapAttributeNumber
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27

References AccessShareLock, ACL_SELECT, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), AtEOXact_GUC(), bms_add_member(), RI_ConstraintInfo::confmatchtype, RI_ConstraintInfo::conname, StringInfoData::data, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, errtableconstraint(), ExecCheckPermissions(), ExecDropSingleTupleTableSlot(), ExecStoreVirtualTuple(), FirstLowInvalidHeapAttributeNumber, RI_ConstraintInfo::fk_attnums, FKCONSTR_MATCH_FULL, FKCONSTR_MATCH_SIMPLE, GetLatestSnapshot(), GetUserId(), GUC_ACTION_SAVE, has_bypassrls_privilege(), heap_deform_tuple(), i, if(), initStringInfo(), InvalidSnapshot, lappend(), list_length(), maintenance_work_mem, makeNode, MakeSingleTupleTableSlot(), MAX_QUOTED_NAME_LEN, MAX_QUOTED_REL_NAME_LEN, NameStr, NewGUCNestLevel(), NIL, RI_ConstraintInfo::nkeys, object_ownercheck(), RI_ConstraintInfo::pf_eq_oprs, PGC_S_SESSION, PGC_USERSET, RI_ConstraintInfo::pk_attnums, quoteOneName(), quoteRelationName(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RTEPermissionInfo::relid, RTEPermissionInfo::requiredPerms, ri_FetchConstraintInfo(), ri_GenerateQual(), ri_GenerateQualCollation(), RI_KEYS_NONE_NULL, ri_NullCheck(), RI_PLAN_CHECK_LOOKUPPK, ri_ReportViolation(), RIAttCollation, RIAttName, RIAttType, RTE_RELATION, RangeTblEntry::rtekind, RTEPermissionInfo::selectedCols, set_config_option(), snprintf, SPI_connect(), SPI_execute_snapshot(), SPI_finish(), SPI_OK_FINISH, SPI_OK_SELECT, SPI_prepare(), SPI_processed, SPI_result, SPI_result_code_string(), SPI_tuptable, TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, TTSOpsVirtual, SPITupleTable::tupdesc, and SPITupleTable::vals.

Referenced by validateForeignKeyConstraint().

◆ RI_PartitionRemove_Check()

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

Definition at line 1811 of file ri_triggers.c.

1812{
1813 const RI_ConstraintInfo *riinfo;
1814 StringInfoData querybuf;
1815 char *constraintDef;
1816 char pkrelname[MAX_QUOTED_REL_NAME_LEN];
1817 char fkrelname[MAX_QUOTED_REL_NAME_LEN];
1818 char pkattname[MAX_QUOTED_NAME_LEN + 3];
1819 char fkattname[MAX_QUOTED_NAME_LEN + 3];
1820 const char *sep;
1821 const char *fk_only;
1822 int save_nestlevel;
1823 char workmembuf[32];
1824 int spi_result;
1825 SPIPlanPtr qplan;
1826 int i;
1827
1828 riinfo = ri_FetchConstraintInfo(trigger, fk_rel, false);
1829
1830 /*
1831 * We don't check permissions before displaying the error message, on the
1832 * assumption that the user detaching the partition must have enough
1833 * privileges to examine the table contents anyhow.
1834 */
1835
1836 /*----------
1837 * The query string built is:
1838 * SELECT fk.keycols FROM [ONLY] relname fk
1839 * JOIN pkrelname pk
1840 * ON (pk.pkkeycol1=fk.keycol1 [AND ...])
1841 * WHERE (<partition constraint>) AND
1842 * For MATCH SIMPLE:
1843 * (fk.keycol1 IS NOT NULL [AND ...])
1844 * For MATCH FULL:
1845 * (fk.keycol1 IS NOT NULL [OR ...])
1846 *
1847 * We attach COLLATE clauses to the operators when comparing columns
1848 * that have different collations.
1849 *----------
1850 */
1851 initStringInfo(&querybuf);
1852 appendStringInfoString(&querybuf, "SELECT ");
1853 sep = "";
1854 for (i = 0; i < riinfo->nkeys; i++)
1855 {
1856 quoteOneName(fkattname,
1857 RIAttName(fk_rel, riinfo->fk_attnums[i]));
1858 appendStringInfo(&querybuf, "%sfk.%s", sep, fkattname);
1859 sep = ", ";
1860 }
1861
1862 quoteRelationName(pkrelname, pk_rel);
1863 quoteRelationName(fkrelname, fk_rel);
1864 fk_only = fk_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE ?
1865 "" : "ONLY ";
1866 appendStringInfo(&querybuf,
1867 " FROM %s%s fk JOIN %s pk ON",
1868 fk_only, fkrelname, pkrelname);
1869 strcpy(pkattname, "pk.");
1870 strcpy(fkattname, "fk.");
1871 sep = "(";
1872 for (i = 0; i < riinfo->nkeys; i++)
1873 {
1874 Oid pk_type = RIAttType(pk_rel, riinfo->pk_attnums[i]);
1875 Oid fk_type = RIAttType(fk_rel, riinfo->fk_attnums[i]);
1876 Oid pk_coll = RIAttCollation(pk_rel, riinfo->pk_attnums[i]);
1877 Oid fk_coll = RIAttCollation(fk_rel, riinfo->fk_attnums[i]);
1878
1879 quoteOneName(pkattname + 3,
1880 RIAttName(pk_rel, riinfo->pk_attnums[i]));
1881 quoteOneName(fkattname + 3,
1882 RIAttName(fk_rel, riinfo->fk_attnums[i]));
1883 ri_GenerateQual(&querybuf, sep,
1884 pkattname, pk_type,
1885 riinfo->pf_eq_oprs[i],
1886 fkattname, fk_type);
1887 if (pk_coll != fk_coll)
1888 ri_GenerateQualCollation(&querybuf, pk_coll);
1889 sep = "AND";
1890 }
1891
1892 /*
1893 * Start the WHERE clause with the partition constraint (except if this is
1894 * the default partition and there's no other partition, because the
1895 * partition constraint is the empty string in that case.)
1896 */
1897 constraintDef = pg_get_partconstrdef_string(RelationGetRelid(pk_rel), "pk");
1898 if (constraintDef && constraintDef[0] != '\0')
1899 appendStringInfo(&querybuf, ") WHERE %s AND (",
1900 constraintDef);
1901 else
1902 appendStringInfoString(&querybuf, ") WHERE (");
1903
1904 sep = "";
1905 for (i = 0; i < riinfo->nkeys; i++)
1906 {
1907 quoteOneName(fkattname, RIAttName(fk_rel, riinfo->fk_attnums[i]));
1908 appendStringInfo(&querybuf,
1909 "%sfk.%s IS NOT NULL",
1910 sep, fkattname);
1911 switch (riinfo->confmatchtype)
1912 {
1913 case FKCONSTR_MATCH_SIMPLE:
1914 sep = " AND ";
1915 break;
1916 case FKCONSTR_MATCH_FULL:
1917 sep = " OR ";
1918 break;
1919 }
1920 }
1921 appendStringInfoChar(&querybuf, ')');
1922
1923 /*
1924 * Temporarily increase work_mem so that the check query can be executed
1925 * more efficiently. It seems okay to do this because the query is simple
1926 * enough to not use a multiple of work_mem, and one typically would not
1927 * have many large foreign-key validations happening concurrently. So
1928 * this seems to meet the criteria for being considered a "maintenance"
1929 * operation, and accordingly we use maintenance_work_mem. However, we
1930 * must also set hash_mem_multiplier to 1, since it is surely not okay to
1931 * let that get applied to the maintenance_work_mem value.
1932 *
1933 * We use the equivalent of a function SET option to allow the setting to
1934 * persist for exactly the duration of the check query. guc.c also takes
1935 * care of undoing the setting on error.
1936 */
1937 save_nestlevel = NewGUCNestLevel();
1938
1939 snprintf(workmembuf, sizeof(workmembuf), "%d", maintenance_work_mem);
1940 (void) set_config_option("work_mem", workmembuf,
1941 PGC_USERSET, PGC_S_SESSION,
1942 GUC_ACTION_SAVE, true, 0, false);
1943 (void) set_config_option("hash_mem_multiplier", "1",
1944 PGC_USERSET, PGC_S_SESSION,
1945 GUC_ACTION_SAVE, true, 0, false);
1946
1947 SPI_connect();
1948
1949 /*
1950 * Generate the plan. We don't need to cache it, and there are no
1951 * arguments to the plan.
1952 */
1953 qplan = SPI_prepare(querybuf.data, 0, NULL);
1954
1955 if (qplan == NULL)
1956 elog(ERROR, "SPI_prepare returned %s for %s",
1957 SPI_result_code_string(SPI_result), querybuf.data);
1958
1959 /*
1960 * Run the plan. For safety we force a current snapshot to be used. (In
1961 * transaction-snapshot mode, this arguably violates transaction isolation
1962 * rules, but we really haven't got much choice.) We don't need to
1963 * register the snapshot, because SPI_execute_snapshot will see to it. We
1964 * need at most one tuple returned, so pass limit = 1.
1965 */
1966 spi_result = SPI_execute_snapshot(qplan,
1967 NULL, NULL,
1968 GetLatestSnapshot(),
1969 InvalidSnapshot,
1970 true, false, 1);
1971
1972 /* Check result */
1973 if (spi_result != SPI_OK_SELECT)
1974 elog(ERROR, "SPI_execute_snapshot returned %s", SPI_result_code_string(spi_result));
1975
1976 /* Did we find a tuple that would violate the constraint? */
1977 if (SPI_processed > 0)
1978 {
1979 TupleTableSlot *slot;
1980 HeapTuple tuple = SPI_tuptable->vals[0];
1981 TupleDesc tupdesc = SPI_tuptable->tupdesc;
1982 RI_ConstraintInfo fake_riinfo;
1983
1984 slot = MakeSingleTupleTableSlot(tupdesc, &TTSOpsVirtual);
1985
1986 heap_deform_tuple(tuple, tupdesc,
1987 slot->tts_values, slot->tts_isnull);
1988 ExecStoreVirtualTuple(slot);
1989
1990 /*
1991 * The columns to look at in the result tuple are 1..N, not whatever
1992 * they are in the fk_rel. Hack up riinfo so that ri_ReportViolation
1993 * will behave properly.
1994 *
1995 * In addition to this, we have to pass the correct tupdesc to
1996 * ri_ReportViolation, overriding its normal habit of using the pk_rel
1997 * or fk_rel's tupdesc.
1998 */
1999 memcpy(&fake_riinfo, riinfo, sizeof(RI_ConstraintInfo));
2000 for (i = 0; i < fake_riinfo.nkeys; i++)
2001 fake_riinfo.pk_attnums[i] = i + 1;
2002
2003 ri_ReportViolation(&fake_riinfo, pk_rel, fk_rel,
2004 slot, tupdesc, 0, false, true);
2005 }
2006
2007 if (SPI_finish() != SPI_OK_FINISH)
2008 elog(ERROR, "SPI_finish failed");
2009
2010 /*
2011 * Restore work_mem and hash_mem_multiplier.
2012 */
2013 AtEOXact_GUC(true, save_nestlevel);
2014}
pg_get_partconstrdef_string
char * pg_get_partconstrdef_string(Oid partitionId, char *aliasname)
Definition: ruleutils.c:2127

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), AtEOXact_GUC(), RI_ConstraintInfo::confmatchtype, StringInfoData::data, elog, ERROR, ExecStoreVirtualTuple(), RI_ConstraintInfo::fk_attnums, FKCONSTR_MATCH_FULL, FKCONSTR_MATCH_SIMPLE, GetLatestSnapshot(), GUC_ACTION_SAVE, heap_deform_tuple(), i, initStringInfo(), InvalidSnapshot, maintenance_work_mem, MakeSingleTupleTableSlot(), MAX_QUOTED_NAME_LEN, MAX_QUOTED_REL_NAME_LEN, NewGUCNestLevel(), RI_ConstraintInfo::nkeys, RI_ConstraintInfo::pf_eq_oprs, pg_get_partconstrdef_string(), PGC_S_SESSION, PGC_USERSET, RI_ConstraintInfo::pk_attnums, quoteOneName(), quoteRelationName(), RelationData::rd_rel, RelationGetRelid, ri_FetchConstraintInfo(), ri_GenerateQual(), ri_GenerateQualCollation(), ri_ReportViolation(), RIAttCollation, RIAttName, RIAttType, set_config_option(), snprintf, SPI_connect(), SPI_execute_snapshot(), SPI_finish(), SPI_OK_FINISH, SPI_OK_SELECT, SPI_prepare(), SPI_processed, SPI_result, SPI_result_code_string(), SPI_tuptable, TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, TTSOpsVirtual, SPITupleTable::tupdesc, and SPITupleTable::vals.

Referenced by ATDetachCheckNoForeignKeyRefs().

◆ TriggerSetParentTrigger()

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

Definition at line 1220 of file trigger.c.

1224{
1225 SysScanDesc tgscan;
1226 ScanKeyData skey[1];
1227 Form_pg_trigger trigForm;
1228 HeapTuple tuple,
1229 newtup;
1230 ObjectAddress depender;
1231 ObjectAddress referenced;
1232
1233 /*
1234 * Find the trigger to delete.
1235 */
1236 ScanKeyInit(&skey[0],
1237 Anum_pg_trigger_oid,
1238 BTEqualStrategyNumber, F_OIDEQ,
1239 ObjectIdGetDatum(childTrigId));
1240
1241 tgscan = systable_beginscan(trigRel, TriggerOidIndexId, true,
1242 NULL, 1, skey);
1243
1244 tuple = systable_getnext(tgscan);
1245 if (!HeapTupleIsValid(tuple))
1246 elog(ERROR, "could not find tuple for trigger %u", childTrigId);
1247 newtup = heap_copytuple(tuple);
1248 trigForm = (Form_pg_trigger) GETSTRUCT(newtup);
1249 if (OidIsValid(parentTrigId))
1250 {
1251 /* don't allow setting parent for a constraint that already has one */
1252 if (OidIsValid(trigForm->tgparentid))
1253 elog(ERROR, "trigger %u already has a parent trigger",
1254 childTrigId);
1255
1256 trigForm->tgparentid = parentTrigId;
1257
1258 CatalogTupleUpdate(trigRel, &tuple->t_self, newtup);
1259
1260 ObjectAddressSet(depender, TriggerRelationId, childTrigId);
1261
1262 ObjectAddressSet(referenced, TriggerRelationId, parentTrigId);
1263 recordDependencyOn(&depender, &referenced, DEPENDENCY_PARTITION_PRI);
1264
1265 ObjectAddressSet(referenced, RelationRelationId, childTableId);
1266 recordDependencyOn(&depender, &referenced, DEPENDENCY_PARTITION_SEC);
1267 }
1268 else
1269 {
1270 trigForm->tgparentid = InvalidOid;
1271
1272 CatalogTupleUpdate(trigRel, &tuple->t_self, newtup);
1273
1274 deleteDependencyRecordsForClass(TriggerRelationId, childTrigId,
1275 TriggerRelationId,
1276 DEPENDENCY_PARTITION_PRI);
1277 deleteDependencyRecordsForClass(TriggerRelationId, childTrigId,
1278 RelationRelationId,
1279 DEPENDENCY_PARTITION_SEC);
1280 }
1281
1282 heap_freetuple(newtup);
1283 systable_endscan(tgscan);
1284}
deleteDependencyRecordsForClass
long deleteDependencyRecordsForClass(Oid classId, Oid objectId, Oid refclassId, char deptype)
Definition: pg_depend.c:351

References BTEqualStrategyNumber, CatalogTupleUpdate(), deleteDependencyRecordsForClass(), DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, elog, ERROR, GETSTRUCT(), heap_copytuple(), heap_freetuple(), HeapTupleIsValid, InvalidOid, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, recordDependencyOn(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), and HeapTupleData::t_self.

Referenced by AttachPartitionForeignKey(), and DetachPartitionFinalize().

Variable Documentation

◆ SessionReplicationRole

PGDLLIMPORT int SessionReplicationRole
extern

Definition at line 63 of file trigger.c.

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