PostgreSQL Source Code git master
Loading...
Searching...
No Matches
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 109 of file trigger.h.

◆ AFTER_TRIGGER_INITDEFERRED

#define AFTER_TRIGGER_INITDEFERRED   0x00000040

Definition at line 110 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.

31{
32 NodeTag type;
33 TriggerEvent tg_event;
34 Relation tg_relation;
35 HeapTuple tg_trigtuple;
36 HeapTuple tg_newtuple;
37 Trigger *tg_trigger;
38 TupleTableSlot *tg_trigslot;
39 TupleTableSlot *tg_newslot;
40 Tuplestorestate *tg_oldtable;
41 Tuplestorestate *tg_newtable;
42 const Bitmapset *tg_updatedcols;
43} TriggerData;
44
45/*
46 * The state for capturing old and new tuples into transition tables for a
47 * single ModifyTable node (or other operation source, e.g. copyfrom.c).
48 *
49 * This is per-caller to avoid conflicts in setting
50 * tcs_original_insert_tuple. Note, however, that the pointed-to
51 * private data may be shared across multiple callers.
52 */
53struct AfterTriggersTableData; /* private in trigger.c */
54
55typedef struct TransitionCaptureState
56{
57 /*
58 * Is there at least one trigger specifying each transition relation on
59 * the relation explicitly named in the DML statement or COPY command?
60 * Note: in current usage, these flags could be part of the private state,
61 * but it seems possibly useful to let callers see them.
62 */
63 bool tcs_delete_old_table;
64 bool tcs_update_old_table;
65 bool tcs_update_new_table;
66 bool tcs_insert_new_table;
67
68 /*
69 * For INSERT and COPY, it would be wasteful to convert tuples from child
70 * format to parent format after they have already been converted in the
71 * opposite direction during routing. In that case we bypass conversion
72 * and allow the inserting code (copyfrom.c and nodeModifyTable.c) to
73 * provide a slot containing the original tuple directly.
74 */
75 TupleTableSlot *tcs_original_insert_tuple;
76
77 /*
78 * Private data including the tuplestore(s) into which to insert tuples.
79 */
80 struct AfterTriggersTableData *tcs_insert_private;
81 struct AfterTriggersTableData *tcs_update_private;
82 struct AfterTriggersTableData *tcs_delete_private;
83} TransitionCaptureState;
84
85/*
86 * TriggerEvent bit flags
87 *
88 * Note that we assume different event types (INSERT/DELETE/UPDATE/TRUNCATE)
89 * can't be OR'd together in a single TriggerEvent. This is unlike the
90 * situation for pg_trigger rows, so pg_trigger.tgtype uses a different
91 * representation!
92 */
93#define TRIGGER_EVENT_INSERT 0x00000000
94#define TRIGGER_EVENT_DELETE 0x00000001
95#define TRIGGER_EVENT_UPDATE 0x00000002
96#define TRIGGER_EVENT_TRUNCATE 0x00000003
97#define TRIGGER_EVENT_OPMASK 0x00000003
98
99#define TRIGGER_EVENT_ROW 0x00000004
100
101#define TRIGGER_EVENT_BEFORE 0x00000008
102#define TRIGGER_EVENT_AFTER 0x00000000
103#define TRIGGER_EVENT_INSTEAD 0x00000010
104#define TRIGGER_EVENT_TIMINGMASK 0x00000018
105
106/* More TriggerEvent flags, used only within trigger.c */
107
108#define AFTER_TRIGGER_DEFERRABLE 0x00000020
109#define AFTER_TRIGGER_INITDEFERRED 0x00000040
110
111#define TRIGGER_FIRED_BY_INSERT(event) \
112 (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_INSERT)
113
114#define TRIGGER_FIRED_BY_DELETE(event) \
115 (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_DELETE)
116
117#define TRIGGER_FIRED_BY_UPDATE(event) \
118 (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_UPDATE)
119
120#define TRIGGER_FIRED_BY_TRUNCATE(event) \
121 (((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_TRUNCATE)
122
123#define TRIGGER_FIRED_FOR_ROW(event) \
124 ((event) & TRIGGER_EVENT_ROW)
125
126#define TRIGGER_FIRED_FOR_STATEMENT(event) \
127 (!TRIGGER_FIRED_FOR_ROW(event))
128
129#define TRIGGER_FIRED_BEFORE(event) \
130 (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_BEFORE)
131
132#define TRIGGER_FIRED_AFTER(event) \
133 (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_AFTER)
134
135#define TRIGGER_FIRED_INSTEAD(event) \
136 (((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_INSTEAD)
137
138/*
139 * Definitions for replication role based firing.
140 */
141#define SESSION_REPLICATION_ROLE_ORIGIN 0
142#define SESSION_REPLICATION_ROLE_REPLICA 1
143#define SESSION_REPLICATION_ROLE_LOCAL 2
144extern PGDLLIMPORT int SessionReplicationRole;
145
146/*
147 * States at which a trigger can be fired. These are the
148 * possible values for pg_trigger.tgenabled.
149 */
150#define TRIGGER_FIRES_ON_ORIGIN 'O'
151#define TRIGGER_FIRES_ALWAYS 'A'
152#define TRIGGER_FIRES_ON_REPLICA 'R'
153#define TRIGGER_DISABLED 'D'
154
155extern ObjectAddress CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
156 Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid,
157 Oid funcoid, Oid parentTriggerOid, Node *whenClause,
158 bool isInternal, bool in_partition);
159extern ObjectAddress CreateTriggerFiringOn(CreateTrigStmt *stmt, const char *queryString,
160 Oid relOid, Oid refRelOid, Oid constraintOid,
161 Oid indexOid, Oid funcoid, Oid parentTriggerOid,
162 Node *whenClause, bool isInternal, bool in_partition,
163 char trigger_fires_when);
164
165extern void TriggerSetParentTrigger(Relation trigRel,
166 Oid childTrigId,
167 Oid parentTrigId,
168 Oid childTableId);
169extern void RemoveTriggerById(Oid trigOid);
170extern Oid get_trigger_oid(Oid relid, const char *trigname, bool missing_ok);
171
172extern ObjectAddress renametrig(RenameStmt *stmt);
173
174extern void EnableDisableTrigger(Relation rel, const char *tgname, Oid tgparent,
175 char fires_when, bool skip_system, bool recurse,
176 LOCKMODE lockmode);
177
178extern void RelationBuildTriggers(Relation relation);
179
180extern TriggerDesc *CopyTriggerDesc(TriggerDesc *trigdesc);
181
182extern const char *FindTriggerIncompatibleWithInheritance(TriggerDesc *trigdesc);
183
184extern TransitionCaptureState *MakeTransitionCaptureState(TriggerDesc *trigdesc,
185 Oid relid, CmdType cmdType);
186
187extern void FreeTriggerDesc(TriggerDesc *trigdesc);
188
189extern void ExecBSInsertTriggers(EState *estate,
190 ResultRelInfo *relinfo);
191extern void ExecASInsertTriggers(EState *estate,
192 ResultRelInfo *relinfo,
193 TransitionCaptureState *transition_capture);
194extern bool ExecBRInsertTriggers(EState *estate,
195 ResultRelInfo *relinfo,
196 TupleTableSlot *slot);
197extern void ExecARInsertTriggers(EState *estate,
198 ResultRelInfo *relinfo,
199 TupleTableSlot *slot,
200 List *recheckIndexes,
201 TransitionCaptureState *transition_capture);
202extern bool ExecIRInsertTriggers(EState *estate,
203 ResultRelInfo *relinfo,
204 TupleTableSlot *slot);
205extern void ExecBSDeleteTriggers(EState *estate,
206 ResultRelInfo *relinfo);
207extern void ExecASDeleteTriggers(EState *estate,
208 ResultRelInfo *relinfo,
209 TransitionCaptureState *transition_capture);
210extern bool ExecBRDeleteTriggers(EState *estate,
211 EPQState *epqstate,
212 ResultRelInfo *relinfo,
213 ItemPointer tupleid,
214 HeapTuple fdw_trigtuple,
215 TupleTableSlot **epqslot,
216 TM_Result *tmresult,
217 TM_FailureData *tmfd,
218 bool is_merge_delete);
219extern void ExecARDeleteTriggers(EState *estate,
220 ResultRelInfo *relinfo,
221 ItemPointer tupleid,
222 HeapTuple fdw_trigtuple,
223 TransitionCaptureState *transition_capture,
224 bool is_crosspart_update);
225extern bool ExecIRDeleteTriggers(EState *estate,
226 ResultRelInfo *relinfo,
227 HeapTuple trigtuple);
228extern void ExecBSUpdateTriggers(EState *estate,
229 ResultRelInfo *relinfo);
230extern void ExecASUpdateTriggers(EState *estate,
231 ResultRelInfo *relinfo,
232 TransitionCaptureState *transition_capture);
233extern bool ExecBRUpdateTriggers(EState *estate,
234 EPQState *epqstate,
235 ResultRelInfo *relinfo,
236 ItemPointer tupleid,
237 HeapTuple fdw_trigtuple,
238 TupleTableSlot *newslot,
239 TM_Result *tmresult,
240 TM_FailureData *tmfd,
241 bool is_merge_update);
242extern void ExecARUpdateTriggers(EState *estate,
243 ResultRelInfo *relinfo,
244 ResultRelInfo *src_partinfo,
245 ResultRelInfo *dst_partinfo,
246 ItemPointer tupleid,
247 HeapTuple fdw_trigtuple,
248 TupleTableSlot *newslot,
249 List *recheckIndexes,
250 TransitionCaptureState *transition_capture,
251 bool is_crosspart_update);
252extern bool ExecIRUpdateTriggers(EState *estate,
253 ResultRelInfo *relinfo,
254 HeapTuple trigtuple,
255 TupleTableSlot *newslot);
256extern void ExecBSTruncateTriggers(EState *estate,
257 ResultRelInfo *relinfo);
258extern void ExecASTruncateTriggers(EState *estate,
259 ResultRelInfo *relinfo);
260
261extern void AfterTriggerBeginXact(void);
262extern void AfterTriggerBeginQuery(void);
263extern void AfterTriggerEndQuery(EState *estate);
264extern void AfterTriggerFireDeferred(void);
265extern void AfterTriggerEndXact(bool isCommit);
266extern void AfterTriggerBeginSubXact(void);
267extern void AfterTriggerEndSubXact(bool isCommit);
268extern void AfterTriggerSetState(ConstraintsSetStmt *stmt);
269extern bool AfterTriggerPendingOnRel(Oid relid);
270
271
272/*
273 * in utils/adt/ri_triggers.c
274 */
275extern bool RI_FKey_pk_upd_check_required(Trigger *trigger, Relation pk_rel,
276 TupleTableSlot *oldslot, TupleTableSlot *newslot);
277extern bool RI_FKey_fk_upd_check_required(Trigger *trigger, Relation fk_rel,
278 TupleTableSlot *oldslot, TupleTableSlot *newslot);
279extern bool RI_Initial_Check(Trigger *trigger,
280 Relation fk_rel, Relation pk_rel);
281extern void RI_PartitionRemove_Check(Trigger *trigger, Relation fk_rel,
282 Relation pk_rel);
283
284/* result values for RI_FKey_trigger_type: */
285#define RI_TRIGGER_PK 1 /* is a trigger on the PK relation */
286#define RI_TRIGGER_FK 2 /* is a trigger on the FK relation */
287#define RI_TRIGGER_NONE 0 /* is not an RI trigger function */
288
289extern int RI_FKey_trigger_type(Oid tgfoid);
290
291#endif /* TRIGGER_H */
PGDLLIMPORT
#define PGDLLIMPORT
Definition c.h:1334
stmt
#define stmt
Definition indent_codes.h:59
LOCKMODE
int LOCKMODE
Definition lockdefs.h:26
CmdType
CmdType
Definition nodes.h:273
NodeTag
NodeTag
Definition nodes.h:27
Oid
unsigned int Oid
Definition postgres_ext.h:32
fb
static int fb(int x)
Definition preproc-init.c:92
List
Definition pg_list.h:54
Node
Definition nodes.h:135
TM_FailureData
Definition tableam.h:148
TransitionCaptureState::tcs_original_insert_tuple
TupleTableSlot * tcs_original_insert_tuple
Definition trigger.h:76
TransitionCaptureState::tcs_insert_private
struct AfterTriggersTableData * tcs_insert_private
Definition trigger.h:81
TransitionCaptureState::tcs_update_private
struct AfterTriggersTableData * tcs_update_private
Definition trigger.h:82
TransitionCaptureState::tcs_delete_private
struct AfterTriggersTableData * tcs_delete_private
Definition trigger.h:83
TM_Result
TM_Result
Definition tableam.h:73
TriggerEvent
uint32 TriggerEvent
Definition trigger.h:29
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 trigger.c:2971
MakeTransitionCaptureState
TransitionCaptureState * MakeTransitionCaptureState(TriggerDesc *trigdesc, Oid relid, CmdType cmdType)
Definition trigger.c:4957
AfterTriggerBeginXact
void AfterTriggerBeginXact(void)
Definition trigger.c:5083
ExecARDeleteTriggers
void ExecARDeleteTriggers(EState *estate, ResultRelInfo *relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TransitionCaptureState *transition_capture, bool is_crosspart_update)
Definition trigger.c:2801
ExecBSInsertTriggers
void ExecBSInsertTriggers(EState *estate, ResultRelInfo *relinfo)
Definition trigger.c:2401
ExecBRInsertTriggers
bool ExecBRInsertTriggers(EState *estate, ResultRelInfo *relinfo, TupleTableSlot *slot)
Definition trigger.c:2465
AfterTriggerEndSubXact
void AfterTriggerEndSubXact(bool isCommit)
Definition trigger.c:5438
RI_FKey_pk_upd_check_required
bool RI_FKey_pk_upd_check_required(Trigger *trigger, Relation pk_rel, TupleTableSlot *oldslot, TupleTableSlot *newslot)
Definition ri_triggers.c:1386
ExecBSTruncateTriggers
void ExecBSTruncateTriggers(EState *estate, ResultRelInfo *relinfo)
Definition trigger.c:3280
SessionReplicationRole
PGDLLIMPORT int SessionReplicationRole
Definition trigger.c:63
FreeTriggerDesc
void FreeTriggerDesc(TriggerDesc *trigdesc)
Definition trigger.c:2145
ExecIRDeleteTriggers
bool ExecIRDeleteTriggers(EState *estate, ResultRelInfo *relinfo, HeapTuple trigtuple)
Definition trigger.c:2848
ExecBSDeleteTriggers
void ExecBSDeleteTriggers(EState *estate, ResultRelInfo *relinfo)
Definition trigger.c:2630
EnableDisableTrigger
void EnableDisableTrigger(Relation rel, const char *tgname, Oid tgparent, char fires_when, bool skip_system, bool recurse, LOCKMODE lockmode)
Definition trigger.c:1726
FindTriggerIncompatibleWithInheritance
const char * FindTriggerIncompatibleWithInheritance(TriggerDesc *trigdesc)
Definition trigger.c:2277
ExecIRInsertTriggers
bool ExecIRInsertTriggers(EState *estate, ResultRelInfo *relinfo, TupleTableSlot *slot)
Definition trigger.c:2569
ExecASTruncateTriggers
void ExecASTruncateTriggers(EState *estate, ResultRelInfo *relinfo)
Definition trigger.c:3327
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 trigger.c:3144
AfterTriggerSetState
void AfterTriggerSetState(ConstraintsSetStmt *stmt)
Definition trigger.c:5766
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 trigger.c:2701
get_trigger_oid
Oid get_trigger_oid(Oid relid, const char *trigname, bool missing_ok)
Definition trigger.c:1370
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 trigger.c:160
ExecASUpdateTriggers
void ExecASUpdateTriggers(EState *estate, ResultRelInfo *relinfo, TransitionCaptureState *transition_capture)
Definition trigger.c:2953
ExecASDeleteTriggers
void ExecASDeleteTriggers(EState *estate, ResultRelInfo *relinfo, TransitionCaptureState *transition_capture)
Definition trigger.c:2681
renametrig
ObjectAddress renametrig(RenameStmt *stmt)
Definition trigger.c:1467
AfterTriggerFireDeferred
void AfterTriggerFireDeferred(void)
Definition trigger.c:5286
ExecARInsertTriggers
void ExecARInsertTriggers(EState *estate, ResultRelInfo *relinfo, TupleTableSlot *slot, List *recheckIndexes, TransitionCaptureState *transition_capture)
Definition trigger.c:2543
TriggerSetParentTrigger
void TriggerSetParentTrigger(Relation trigRel, Oid childTrigId, Oid parentTrigId, Oid childTableId)
Definition trigger.c:1220
ExecASInsertTriggers
void ExecASInsertTriggers(EState *estate, ResultRelInfo *relinfo, TransitionCaptureState *transition_capture)
Definition trigger.c:2452
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
CopyTriggerDesc
TriggerDesc * CopyTriggerDesc(TriggerDesc *trigdesc)
Definition trigger.c:2090
ExecIRUpdateTriggers
bool ExecIRUpdateTriggers(EState *estate, ResultRelInfo *relinfo, HeapTuple trigtuple, TupleTableSlot *newslot)
Definition trigger.c:3214
AfterTriggerEndXact
void AfterTriggerEndXact(bool isCommit)
Definition trigger.c:5342
AfterTriggerPendingOnRel
bool AfterTriggerPendingOnRel(Oid relid)
Definition trigger.c:6081
RI_Initial_Check
bool RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
Definition ri_triggers.c:1519
RelationBuildTriggers
void RelationBuildTriggers(Relation relation)
Definition trigger.c:1861
AfterTriggerBeginSubXact
void AfterTriggerBeginSubXact(void)
Definition trigger.c:5390
RI_PartitionRemove_Check
void RI_PartitionRemove_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
Definition ri_triggers.c:1813
RI_FKey_fk_upd_check_required
bool RI_FKey_fk_upd_check_required(Trigger *trigger, Relation fk_rel, TupleTableSlot *oldslot, TupleTableSlot *newslot)
Definition ri_triggers.c:1418
RI_FKey_trigger_type
int RI_FKey_trigger_type(Oid tgfoid)
Definition ri_triggers.c:3210
AfterTriggerEndQuery
void AfterTriggerEndQuery(EState *estate)
Definition trigger.c:5135
RemoveTriggerById
void RemoveTriggerById(Oid trigOid)
Definition trigger.c:1291
ExecBSUpdateTriggers
void ExecBSUpdateTriggers(EState *estate, ResultRelInfo *relinfo)
Definition trigger.c:2895
AfterTriggerBeginQuery
void AfterTriggerBeginQuery(void)
Definition trigger.c:5115
type
const char * type
Definition wait_event_funcs.c:27

◆ RI_TRIGGER_FK

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

Definition at line 287 of file trigger.h.

◆ RI_TRIGGER_NONE

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

Definition at line 288 of file trigger.h.

◆ RI_TRIGGER_PK

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

Definition at line 286 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_LOCAL

#define SESSION_REPLICATION_ROLE_LOCAL   2

Definition at line 144 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_ORIGIN

#define SESSION_REPLICATION_ROLE_ORIGIN   0

Definition at line 142 of file trigger.h.

◆ SESSION_REPLICATION_ROLE_REPLICA

#define SESSION_REPLICATION_ROLE_REPLICA   1

Definition at line 143 of file trigger.h.

◆ TRIGGER_DISABLED

#define TRIGGER_DISABLED   'D'

Definition at line 154 of file trigger.h.

◆ TRIGGER_EVENT_AFTER

#define TRIGGER_EVENT_AFTER   0x00000000

Definition at line 103 of file trigger.h.

◆ TRIGGER_EVENT_BEFORE

#define TRIGGER_EVENT_BEFORE   0x00000008

Definition at line 102 of file trigger.h.

◆ TRIGGER_EVENT_DELETE

#define TRIGGER_EVENT_DELETE   0x00000001

Definition at line 95 of file trigger.h.

◆ TRIGGER_EVENT_INSERT

#define TRIGGER_EVENT_INSERT   0x00000000

Definition at line 94 of file trigger.h.

◆ TRIGGER_EVENT_INSTEAD

#define TRIGGER_EVENT_INSTEAD   0x00000010

Definition at line 104 of file trigger.h.

◆ TRIGGER_EVENT_OPMASK

#define TRIGGER_EVENT_OPMASK   0x00000003

Definition at line 98 of file trigger.h.

◆ TRIGGER_EVENT_ROW

#define TRIGGER_EVENT_ROW   0x00000004

Definition at line 100 of file trigger.h.

◆ TRIGGER_EVENT_TIMINGMASK

#define TRIGGER_EVENT_TIMINGMASK   0x00000018

Definition at line 105 of file trigger.h.

◆ TRIGGER_EVENT_TRUNCATE

#define TRIGGER_EVENT_TRUNCATE   0x00000003

Definition at line 97 of file trigger.h.

◆ TRIGGER_EVENT_UPDATE

#define TRIGGER_EVENT_UPDATE   0x00000002

Definition at line 96 of file trigger.h.

◆ TRIGGER_FIRED_AFTER

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

Definition at line 133 of file trigger.h.

◆ TRIGGER_FIRED_BEFORE

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

Definition at line 130 of file trigger.h.

◆ TRIGGER_FIRED_BY_DELETE

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

Definition at line 115 of file trigger.h.

◆ TRIGGER_FIRED_BY_INSERT

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

Definition at line 112 of file trigger.h.

◆ TRIGGER_FIRED_BY_TRUNCATE

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

Definition at line 121 of file trigger.h.

◆ TRIGGER_FIRED_BY_UPDATE

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

Definition at line 118 of file trigger.h.

◆ TRIGGER_FIRED_FOR_ROW

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

Definition at line 124 of file trigger.h.

◆ TRIGGER_FIRED_FOR_STATEMENT

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

Definition at line 127 of file trigger.h.

◆ TRIGGER_FIRED_INSTEAD

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

Definition at line 136 of file trigger.h.

◆ TRIGGER_FIRES_ALWAYS

#define TRIGGER_FIRES_ALWAYS   'A'

Definition at line 152 of file trigger.h.

◆ TRIGGER_FIRES_ON_ORIGIN

#define TRIGGER_FIRES_ON_ORIGIN   'O'

Definition at line 151 of file trigger.h.

◆ TRIGGER_FIRES_ON_REPLICA

#define TRIGGER_FIRES_ON_REPLICA   'R'

Definition at line 153 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  )
extern

Definition at line 5115 of file trigger.c.

5116{
5117 /* Increase the query stack depth */
5118 afterTriggers.query_depth++;
5119}
afterTriggers
static AfterTriggersData afterTriggers
Definition trigger.c:3930

References afterTriggers, and AfterTriggersData::query_depth.

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

◆ AfterTriggerBeginSubXact()

void AfterTriggerBeginSubXact ( void  )
extern

Definition at line 5390 of file trigger.c.

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

Definition at line 5083 of file trigger.c.

5084{
5085 /*
5086 * Initialize after-trigger state structure to empty
5087 */
5088 afterTriggers.firing_counter = (CommandId) 1; /* mustn't be 0 */
5089 afterTriggers.query_depth = -1;
5090
5091 /*
5092 * Verify that there is no leftover state remaining. If these assertions
5093 * trip, it means that AfterTriggerEndXact wasn't called or didn't clean
5094 * up properly.
5095 */
5096 Assert(afterTriggers.state == NULL);
5097 Assert(afterTriggers.query_stack == NULL);
5098 Assert(afterTriggers.maxquerydepth == 0);
5099 Assert(afterTriggers.event_cxt == NULL);
5100 Assert(afterTriggers.events.head == NULL);
5101 Assert(afterTriggers.trans_stack == NULL);
5102 Assert(afterTriggers.maxtransdepth == 0);
5103}
Assert
#define Assert(condition)
Definition c.h:873
CommandId
uint32 CommandId
Definition c.h:680
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, fb(), 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)
extern

Definition at line 5135 of file trigger.c.

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

References afterTriggerDeleteHeadEventChunk(), AfterTriggerFreeQuery(), afterTriggerInvokeEvents(), afterTriggerMarkEvents(), afterTriggers, Assert, AfterTriggersData::events, fb(), AfterTriggersData::firing_counter, AfterTriggersData::maxquerydepth, AfterTriggersData::query_depth, and AfterTriggersData::query_stack.

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

◆ AfterTriggerEndSubXact()

void AfterTriggerEndSubXact ( bool  isCommit)
extern

Definition at line 5438 of file trigger.c.

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

Definition at line 5342 of file trigger.c.

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

References afterTriggers, AfterTriggersData::event_cxt, AfterTriggersData::events, fb(), 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  )
extern

Definition at line 5286 of file trigger.c.

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

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

Referenced by CommitTransaction(), and PrepareTransaction().

◆ AfterTriggerPendingOnRel()

bool AfterTriggerPendingOnRel ( Oid  relid)
extern

Definition at line 6081 of file trigger.c.

6082{
6083 AfterTriggerEvent event;
6084 AfterTriggerEventChunk *chunk;
6085 int depth;
6086
6087 /* Scan queued events */
6088 for_each_event_chunk(event, chunk, afterTriggers.events)
6089 {
6090 AfterTriggerShared evtshared = GetTriggerSharedData(event);
6091
6092 /*
6093 * We can ignore completed events. (Even if a DONE flag is rolled
6094 * back by subxact abort, it's OK because the effects of the TRUNCATE
6095 * or whatever must get rolled back too.)
6096 */
6097 if (event->ate_flags & AFTER_TRIGGER_DONE)
6098 continue;
6099
6100 if (evtshared->ats_relid == relid)
6101 return true;
6102 }
6103
6104 /*
6105 * Also scan events queued by incomplete queries. This could only matter
6106 * if TRUNCATE/etc is executed by a function or trigger within an updating
6107 * query on the same relation, which is pretty perverse, but let's check.
6108 */
6109 for (depth = 0; depth <= afterTriggers.query_depth && depth < afterTriggers.maxquerydepth; depth++)
6110 {
6111 for_each_event_chunk(event, chunk, afterTriggers.query_stack[depth].events)
6112 {
6113 AfterTriggerShared evtshared = GetTriggerSharedData(event);
6114
6115 if (event->ate_flags & AFTER_TRIGGER_DONE)
6116 continue;
6117
6118 if (evtshared->ats_relid == relid)
6119 return true;
6120 }
6121 }
6122
6123 return false;
6124}
AfterTriggersQueryData::events
AfterTriggerEventList events
Definition trigger.c:3898

References AFTER_TRIGGER_DONE, afterTriggers, AfterTriggerEventData::ate_flags, AfterTriggersData::events, AfterTriggersQueryData::events, fb(), for_each_event_chunk, GetTriggerSharedData, AfterTriggersData::maxquerydepth, AfterTriggersData::query_depth, and AfterTriggersData::query_stack.

Referenced by CheckTableNotInUse().

◆ AfterTriggerSetState()

void AfterTriggerSetState ( ConstraintsSetStmt *  stmt)
extern

Definition at line 5766 of file trigger.c.

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

References AccessShareLock, afterTriggerInvokeEvents(), afterTriggerMarkEvents(), afterTriggers, SetConstraintStateData::all_isdeferred, SetConstraintStateData::all_isset, BTEqualStrategyNumber, RangeVar::catalogname, CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, AfterTriggersData::events, fb(), fetch_search_path(), AfterTriggersData::firing_counter, get_database_name(), GetCurrentTransactionNestLevel(), GETSTRUCT(), GetTransactionSnapshot(), HeapTupleIsValid, i, IsSubTransaction(), lappend_oid(), lfirst, lfirst_oid, list_free(), list_make1_oid, LookupExplicitNamespace(), MyDatabaseId, NIL, SetConstraintStateData::numstates, ObjectIdGetDatum(), PopActiveSnapshot(), PushActiveSnapshot(), RangeVar::relname, ScanKeyInit(), RangeVar::schemaname, 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)
extern

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 = palloc_object(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:541
palloc_object
#define palloc_object(type)
Definition fe_memutils.h:74
j
int j
Definition isn.c:78
pstrdup
char * pstrdup(const char *in)
Definition mcxt.c:1781
palloc
void * palloc(Size size)
Definition mcxt.c:1387
TriggerDesc::numtriggers
int numtriggers
Definition reltrigger.h:50
TriggerDesc::triggers
Trigger * triggers
Definition reltrigger.h:49

References fb(), i, j, TriggerDesc::numtriggers, palloc(), palloc_object, pstrdup(), 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 
)
extern

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

References CreateTriggerFiringOn(), fb(), 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 
)
extern

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:2654
object_aclcheck
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition aclchk.c:3836
pg_class_aclcheck
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition aclchk.c:4039
InvalidAttrNumber
#define InvalidAttrNumber
Definition attnum.h:23
values
static Datum values[MAXATTR]
Definition bootstrap.c:155
CStringGetTextDatum
#define CStringGetTextDatum(s)
Definition builtins.h:97
byteain
Datum byteain(PG_FUNCTION_ARGS)
Definition bytea.c:201
NameStr
#define NameStr(name)
Definition c.h:765
OidIsValid
#define OidIsValid(objectId)
Definition c.h:788
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:1603
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:684
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:1669
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:2078
get_rel_relkind
char get_rel_relkind(Oid relid)
Definition lsyscache.c:2153
get_func_rettype
Oid get_func_rettype(Oid funcid)
Definition lsyscache.c:1805
makeAlias
Alias * makeAlias(const char *aliasname, List *colnames)
Definition makefuncs.c:438
MemoryContextReset
void MemoryContextReset(MemoryContext context)
Definition mcxt.c:403
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:802
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:1580
addNSItemToQuery
void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)
Definition parse_relation.c:2706
attnameAttNum
int attnameAttNum(Relation rd, const char *attname, bool sysColOK)
Definition parse_relation.c:3585
OBJECT_FUNCTION
@ OBJECT_FUNCTION
Definition parsenodes.h:2371
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:260
PointerGetDatum
static Datum PointerGetDatum(const void *X)
Definition postgres.h:352
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:342
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:514
RelationGetDescr
#define RelationGetDescr(relation)
Definition rel.h:540
RelationGetRelationName
#define RelationGetRelationName(relation)
Definition rel.h:548
RelationGetNamespace
#define RelationGetNamespace(relation)
Definition rel.h:555
ERRCODE_DUPLICATE_OBJECT
#define ERRCODE_DUPLICATE_OBJECT
Definition streamutil.c:30
HeapTupleData::t_self
ItemPointerData t_self
Definition htup.h:65
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_id
Oid rd_id
Definition rel.h:113
RelationData::rd_rel
Form_pg_class rd_rel
Definition rel.h:111
Var::location
ParseLoc location
Definition primnodes.h:310
Var::varattno
AttrNumber varattno
Definition primnodes.h:274
Var::varno
int varno
Definition primnodes.h:269
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, Assert, assign_expr_collations(), attnameAttNum(), attnum, BoolGetDatum(), BTEqualStrategyNumber, buildint2vector(), byteain(), CacheInvalidateRelcacheByTuple(), CatalogTupleInsert(), CatalogTupleUpdate(), CharGetDatum(), 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, fb(), find_all_inheritors(), free_parsestate(), 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, IsSystemRelation(), j, len, lfirst, lfirst_node, list_free(), list_length(), Var::location, LockRelationOid(), LookupFuncName(), make_parsestate(), makeAlias(), map_partition_varattnos(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), name, NAMEDATALEN, namein(), NameListToString(), NameStr, NIL, nodeToString(), NoLock, PartitionDescData::nparts, object_aclcheck(), OBJECT_FUNCTION, ObjectAddressSet, ObjectIdGetDatum(), 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_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, and Var::varno.

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

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:1635
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, fb(), 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(), 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 
)
extern

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
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:6168
TRIGGER_EVENT_DELETE
#define TRIGGER_EVENT_DELETE
Definition trigger.h:95

References AfterTriggerSaveEvent(), Assert, ereport, errcode(), errmsg(), ERROR, ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), fb(), GetTupleForTrigger(), HeapTupleIsValid, ItemPointerIsValid(), LockTupleExclusive, NIL, 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 
)
extern

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

References AfterTriggerSaveEvent(), Assert, ereport, errcode(), errmsg(), ERROR, fb(), 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 
)
extern

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:96
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition tuptable.h:457

References AfterTriggerSaveEvent(), Assert, ereport, errcode(), errmsg(), ERROR, ExecClearTuple(), ExecForceStoreHeapTuple(), ExecGetAllUpdatedCols(), ExecGetTriggerOldSlot(), fb(), GetTupleForTrigger(), ItemPointerIsValid(), LockTupleExclusive, 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 
)
extern

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(), fb(), NIL, TriggerDesc::trig_delete_after_statement, and TRIGGER_EVENT_DELETE.

Referenced by fireASTriggers().

◆ ExecASInsertTriggers()

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

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(), fb(), NIL, TriggerDesc::trig_insert_after_statement, and TRIGGER_EVENT_INSERT.

Referenced by CopyFrom(), and fireASTriggers().

◆ ExecASTruncateTriggers()

void ExecASTruncateTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)
extern

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

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

Referenced by ExecuteTruncateGuts().

◆ ExecASUpdateTriggers()

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

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(), fb(), NIL, 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 
)
extern

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
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:100
TRIGGER_EVENT_BEFORE
#define TRIGGER_EVENT_BEFORE
Definition trigger.h:102

References Assert, ExecCallTriggerFunc(), ExecFetchSlotHeapTuple(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), fb(), GetPerTupleMemoryContext, GetTupleForTrigger(), heap_freetuple(), HeapTupleIsValid, i, ItemPointerIsValid(), LockTupleExclusive, TriggerDesc::numtriggers, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_DELETE, TRIGGER_EVENT_ROW, TriggerEnabled(), and TriggerDesc::triggers.

Referenced by ExecDeletePrologue(), and ExecSimpleRelationDelete().

◆ ExecBRInsertTriggers()

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

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:1860
get_namespace_name
char * get_namespace_name(Oid nspid)
Definition lsyscache.c:3516
TriggerData::type
NodeTag type
Definition trigger.h:33
check_modified_virtual_generated
static HeapTuple check_modified_virtual_generated(TupleDesc tupdesc, HeapTuple tuple)
Definition trigger.c:6734

References check_modified_virtual_generated(), ereport, errcode(), errdetail(), errmsg(), ERROR, ExecCallTriggerFunc(), ExecFetchSlotHeapTuple(), ExecForceStoreHeapTuple(), ExecPartitionCheck(), fb(), get_namespace_name(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, RelationGetDescr, RelationGetNamespace, RelationGetRelationName, 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 
)
extern

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:412
ExecUpdateLockMode
LockTupleMode ExecUpdateLockMode(EState *estate, ResultRelInfo *relinfo)
Definition execMain.c:2534
LockTupleMode
LockTupleMode
Definition lockoptions.h:50
ExecGetUpdateNewTuple
TupleTableSlot * ExecGetUpdateNewTuple(ResultRelInfo *relinfo, TupleTableSlot *planSlot, TupleTableSlot *oldSlot)
Definition nodeModifyTable.c:813
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(), fb(), GetPerTupleMemoryContext, GetTupleForTrigger(), heap_freetuple(), HeapTupleIsValid, i, ItemPointerIsValid(), TriggerDesc::numtriggers, RelationGetDescr, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_ROW, TRIGGER_EVENT_UPDATE, TriggerEnabled(), TriggerDesc::triggers, and unlikely.

Referenced by ExecSimpleRelationUpdate(), and ExecUpdatePrologue().

◆ ExecBSDeleteTriggers()

void ExecBSDeleteTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)
extern

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

References before_stmt_triggers_fired(), CMD_DELETE, ereport, errcode(), errmsg(), ERROR, ExecCallTriggerFunc(), fb(), GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, RelationGetRelid, TriggerDesc::trig_delete_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_DELETE, TriggerEnabled(), and TriggerDesc::triggers.

Referenced by fireBSTriggers().

◆ ExecBSInsertTriggers()

void ExecBSInsertTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)
extern

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(), fb(), GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, RelationGetRelid, TriggerDesc::trig_insert_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_INSERT, TriggerEnabled(), and TriggerDesc::triggers.

Referenced by CopyFrom(), and fireBSTriggers().

◆ ExecBSTruncateTriggers()

void ExecBSTruncateTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)
extern

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(), fb(), GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, TriggerDesc::trig_truncate_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_TRUNCATE, TriggerEnabled(), and TriggerDesc::triggers.

Referenced by ExecuteTruncateGuts().

◆ ExecBSUpdateTriggers()

void ExecBSUpdateTriggers ( EState *  estate,
ResultRelInfo *  relinfo 
)
extern

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(), fb(), GetPerTupleMemoryContext, i, TriggerDesc::numtriggers, RelationGetRelid, TriggerDesc::trig_update_before_statement, TRIGGER_EVENT_BEFORE, TRIGGER_EVENT_UPDATE, TriggerEnabled(), and TriggerDesc::triggers.

Referenced by fireBSTriggers().

◆ ExecIRDeleteTriggers()

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

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

References ExecCallTriggerFunc(), ExecForceStoreHeapTuple(), ExecGetTriggerOldSlot(), fb(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, 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 
)
extern

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(), fb(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, 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 
)
extern

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(), fb(), GetPerTupleMemoryContext, heap_freetuple(), i, TriggerDesc::numtriggers, 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)
extern

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}
Trigger::tgname
char * tgname
Definition reltrigger.h:27

References fb(), i, TriggerDesc::numtriggers, Trigger::tgname, and TriggerDesc::triggers.

Referenced by ATExecAddInherit(), and ATExecAttachPartition().

◆ FreeTriggerDesc()

void FreeTriggerDesc ( TriggerDesc *  trigdesc)
extern

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

Referenced by RelationBuildTriggers(), and RelationDestroyRelation().

◆ get_trigger_oid()

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

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, fb(), 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 
)
extern

Definition at line 4957 of file trigger.c.

4958{
4959 TransitionCaptureState *state;
4960 bool need_old_upd,
4961 need_new_upd,
4962 need_old_del,
4963 need_new_ins;
4964 AfterTriggersTableData *ins_table;
4965 AfterTriggersTableData *upd_table;
4966 AfterTriggersTableData *del_table;
4967 MemoryContext oldcxt;
4968 ResourceOwner saveResourceOwner;
4969
4970 if (trigdesc == NULL)
4971 return NULL;
4972
4973 /* Detect which table(s) we need. */
4974 switch (cmdType)
4975 {
4976 case CMD_INSERT:
4977 need_old_upd = need_old_del = need_new_upd = false;
4978 need_new_ins = trigdesc->trig_insert_new_table;
4979 break;
4980 case CMD_UPDATE:
4981 need_old_upd = trigdesc->trig_update_old_table;
4982 need_new_upd = trigdesc->trig_update_new_table;
4983 need_old_del = need_new_ins = false;
4984 break;
4985 case CMD_DELETE:
4986 need_old_del = trigdesc->trig_delete_old_table;
4987 need_old_upd = need_new_upd = need_new_ins = false;
4988 break;
4989 case CMD_MERGE:
4990 need_old_upd = trigdesc->trig_update_old_table;
4991 need_new_upd = trigdesc->trig_update_new_table;
4992 need_old_del = trigdesc->trig_delete_old_table;
4993 need_new_ins = trigdesc->trig_insert_new_table;
4994 break;
4995 default:
4996 elog(ERROR, "unexpected CmdType: %d", (int) cmdType);
4997 /* keep compiler quiet */
4998 need_old_upd = need_new_upd = need_old_del = need_new_ins = false;
4999 break;
5000 }
5001 if (!need_old_upd && !need_new_upd && !need_new_ins && !need_old_del)
5002 return NULL;
5003
5004 /* Check state, like AfterTriggerSaveEvent. */
5005 if (afterTriggers.query_depth < 0)
5006 elog(ERROR, "MakeTransitionCaptureState() called outside of query");
5007
5008 /* Be sure we have enough space to record events at this query depth. */
5009 if (afterTriggers.query_depth >= afterTriggers.maxquerydepth)
5010 AfterTriggerEnlargeQueryState();
5011
5012 /*
5013 * Find or create AfterTriggersTableData struct(s) to hold the
5014 * tuplestore(s). If there's a matching struct but it's marked closed,
5015 * ignore it; we need a newer one.
5016 *
5017 * Note: MERGE must use the same AfterTriggersTableData structs as INSERT,
5018 * UPDATE, and DELETE, so that any MERGE'd tuples are added to the same
5019 * tuplestores as tuples from any INSERT, UPDATE, or DELETE commands
5020 * running in the same top-level command (e.g., in a writable CTE).
5021 *
5022 * Note: the AfterTriggersTableData list, as well as the tuplestores, are
5023 * allocated in the current (sub)transaction's CurTransactionContext, and
5024 * the tuplestores are managed by the (sub)transaction's resource owner.
5025 * This is sufficient lifespan because we do not allow triggers using
5026 * transition tables to be deferrable; they will be fired during
5027 * AfterTriggerEndQuery, after which it's okay to delete the data.
5028 */
5029 if (need_new_ins)
5030 ins_table = GetAfterTriggersTableData(relid, CMD_INSERT);
5031 else
5032 ins_table = NULL;
5033
5034 if (need_old_upd || need_new_upd)
5035 upd_table = GetAfterTriggersTableData(relid, CMD_UPDATE);
5036 else
5037 upd_table = NULL;
5038
5039 if (need_old_del)
5040 del_table = GetAfterTriggersTableData(relid, CMD_DELETE);
5041 else
5042 del_table = NULL;
5043
5044 /* Now create required tuplestore(s), if we don't have them already. */
5045 oldcxt = MemoryContextSwitchTo(CurTransactionContext);
5046 saveResourceOwner = CurrentResourceOwner;
5047 CurrentResourceOwner = CurTransactionResourceOwner;
5048
5049 if (need_old_upd && upd_table->old_tuplestore == NULL)
5050 upd_table->old_tuplestore = tuplestore_begin_heap(false, false, work_mem);
5051 if (need_new_upd && upd_table->new_tuplestore == NULL)
5052 upd_table->new_tuplestore = tuplestore_begin_heap(false, false, work_mem);
5053 if (need_old_del && del_table->old_tuplestore == NULL)
5054 del_table->old_tuplestore = tuplestore_begin_heap(false, false, work_mem);
5055 if (need_new_ins && ins_table->new_tuplestore == NULL)
5056 ins_table->new_tuplestore = tuplestore_begin_heap(false, false, work_mem);
5057
5058 CurrentResourceOwner = saveResourceOwner;
5059 MemoryContextSwitchTo(oldcxt);
5060
5061 /* Now build the TransitionCaptureState struct, in caller's context */
5062 state = palloc0_object(TransitionCaptureState);
5063 state->tcs_delete_old_table = need_old_del;
5064 state->tcs_update_old_table = need_old_upd;
5065 state->tcs_update_new_table = need_new_upd;
5066 state->tcs_insert_new_table = need_new_ins;
5067 state->tcs_insert_private = ins_table;
5068 state->tcs_update_private = upd_table;
5069 state->tcs_delete_private = del_table;
5070
5071 return state;
5072}
palloc0_object
#define palloc0_object(type)
Definition fe_memutils.h:75
work_mem
int work_mem
Definition globals.c:131
CurTransactionContext
MemoryContext CurTransactionContext
Definition mcxt.c:172
CMD_MERGE
@ CMD_MERGE
Definition nodes.h:279
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:4866
AfterTriggerEnlargeQueryState
static void AfterTriggerEnlargeQueryState(void)
Definition trigger.c:5644
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, fb(), GetAfterTriggersTableData(), AfterTriggersData::maxquerydepth, MemoryContextSwitchTo(), palloc0_object, AfterTriggersData::query_depth, TriggerDesc::trig_delete_old_table, TriggerDesc::trig_insert_new_table, TriggerDesc::trig_update_new_table, TriggerDesc::trig_update_old_table, tuplestore_begin_heap(), and work_mem.

Referenced by CopyFrom(), and ExecSetupTransitionCaptureState().

◆ RelationBuildTriggers()

void RelationBuildTriggers ( Relation  relation)
extern

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 = palloc0_object(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:292
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:365
NameGetDatum
static Datum NameGetDatum(const NameData *X)
Definition postgres.h:403
RelationData::trigdesc
TriggerDesc * trigdesc
Definition rel.h:117
Trigger::tgoid
Oid tgoid
Definition reltrigger.h:25
varlena
Definition c.h:706
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(), fb(), FreeTriggerDesc(), GETSTRUCT(), HeapTupleIsValid, i, MemoryContextSwitchTo(), NameGetDatum(), nameout(), TriggerDesc::numtriggers, ObjectIdGetDatum(), OidIsValid, palloc(), palloc0_object, pfree(), pstrdup(), RelationGetRelationName, RelationGetRelid, repalloc(), ScanKeyInit(), SetTriggerFlags(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, Trigger::tgoid, RelationData::trigdesc, TriggerDesc::triggers, val, and VARDATA_ANY().

Referenced by RelationBuildDesc(), and RelationCacheInitializePhase3().

◆ RemoveTriggerById()

void RemoveTriggerById ( Oid  trigOid)
extern

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, fb(), GETSTRUCT(), HeapTupleIsValid, IsSystemRelation(), NoLock, ObjectIdGetDatum(), RelationData::rd_rel, RelationGetRelationName, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by doDeletion().

◆ renametrig()

ObjectAddress renametrig ( RenameStmt *  stmt)
extern

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, fb(), find_all_inheritors(), get_partition_parent(), get_rel_name(), GETSTRUCT(), HeapTupleIsValid, i, NoLock, PartitionDescData::nparts, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, PartitionDescData::oids, PointerGetDatum(), RangeVarCallbackForRenameTrigger(), RangeVarGetRelidExtended(), 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 
)
extern

Definition at line 1418 of file ri_triggers.c.

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

References Assert, fb(), FKCONSTR_MATCH_FULL, FKCONSTR_MATCH_PARTIAL, FKCONSTR_MATCH_SIMPLE, 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 
)
extern

Definition at line 1386 of file ri_triggers.c.

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

References fb(), 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)
extern

Definition at line 3210 of file ri_triggers.c.

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

References fb(), 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 
)
extern

Definition at line 1519 of file ri_triggers.c.

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

Definition at line 1813 of file ri_triggers.c.

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

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), AtEOXact_GUC(), elog, ERROR, ExecStoreVirtualTuple(), fb(), 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(), pg_get_partconstrdef_string(), PGC_S_SESSION, PGC_USERSET, quoteOneName(), quoteRelationName(), 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 
)
extern

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