Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * constraint.c
4 : * PostgreSQL CONSTRAINT support code.
5 : *
6 : * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : * IDENTIFICATION
10 : * src/backend/commands/constraint.c
11 : *
12 : *-------------------------------------------------------------------------
13 : */
14 : #include "postgres.h"
15 :
16 : #include "access/genam.h"
17 : #include "access/heapam.h"
18 : #include "access/tableam.h"
19 : #include "catalog/index.h"
20 : #include "commands/trigger.h"
21 : #include "executor/executor.h"
22 : #include "utils/builtins.h"
23 : #include "utils/rel.h"
24 : #include "utils/snapmgr.h"
25 :
26 :
27 : /*
28 : * unique_key_recheck - trigger function to do a deferred uniqueness check.
29 : *
30 : * This now also does deferred exclusion-constraint checks, so the name is
31 : * somewhat historical.
32 : *
33 : * This is invoked as an AFTER ROW trigger for both INSERT and UPDATE,
34 : * for any rows recorded as potentially violating a deferrable unique
35 : * or exclusion constraint.
36 : *
37 : * This may be an end-of-statement check, a commit-time check, or a
38 : * check triggered by a SET CONSTRAINTS command.
39 : */
40 : Datum
41 122 : unique_key_recheck(PG_FUNCTION_ARGS)
42 : {
43 122 : TriggerData *trigdata = (TriggerData *) fcinfo->context;
44 122 : const char *funcname = "unique_key_recheck";
45 : ItemPointerData checktid;
46 : ItemPointerData tmptid;
47 : Relation indexRel;
48 : IndexInfo *indexInfo;
49 : EState *estate;
50 : ExprContext *econtext;
51 : TupleTableSlot *slot;
52 : Datum values[INDEX_MAX_KEYS];
53 : bool isnull[INDEX_MAX_KEYS];
54 :
55 : /*
56 : * Make sure this is being called as an AFTER ROW trigger. Note:
57 : * translatable error strings are shared with ri_triggers.c, so resist the
58 : * temptation to fold the function name into them.
59 : */
60 122 : if (!CALLED_AS_TRIGGER(fcinfo))
61 0 : ereport(ERROR,
62 : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
63 : errmsg("function \"%s\" was not called by trigger manager",
64 : funcname)));
65 :
66 122 : if (!TRIGGER_FIRED_AFTER(trigdata->tg_event) ||
67 122 : !TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
68 0 : ereport(ERROR,
69 : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
70 : errmsg("function \"%s\" must be fired AFTER ROW",
71 : funcname)));
72 :
73 : /*
74 : * Get the new data that was inserted/updated.
75 : */
76 122 : if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
77 86 : checktid = trigdata->tg_trigslot->tts_tid;
78 36 : else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
79 36 : checktid = trigdata->tg_newslot->tts_tid;
80 : else
81 : {
82 0 : ereport(ERROR,
83 : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
84 : errmsg("function \"%s\" must be fired for INSERT or UPDATE",
85 : funcname)));
86 : ItemPointerSetInvalid(&checktid); /* keep compiler quiet */
87 : }
88 :
89 122 : slot = table_slot_create(trigdata->tg_relation, NULL);
90 :
91 : /*
92 : * If the row pointed at by checktid is now dead (ie, inserted and then
93 : * deleted within our transaction), we can skip the check. However, we
94 : * have to be careful, because this trigger gets queued only in response
95 : * to index insertions; which means it does not get queued e.g. for HOT
96 : * updates. The row we are called for might now be dead, but have a live
97 : * HOT child, in which case we still need to make the check ---
98 : * effectively, we're applying the check against the live child row,
99 : * although we can use the values from this row since by definition all
100 : * columns of interest to us are the same.
101 : *
102 : * This might look like just an optimization, because the index AM will
103 : * make this identical test before throwing an error. But it's actually
104 : * needed for correctness, because the index AM will also throw an error
105 : * if it doesn't find the index entry for the row. If the row's dead then
106 : * it's possible the index entry has also been marked dead, and even
107 : * removed.
108 : */
109 122 : tmptid = checktid;
110 : {
111 122 : IndexFetchTableData *scan = table_index_fetch_begin(trigdata->tg_relation);
112 122 : bool call_again = false;
113 :
114 122 : if (!table_index_fetch_tuple(scan, &tmptid, SnapshotSelf, slot,
115 : &call_again, NULL))
116 : {
117 : /*
118 : * All rows referenced by the index entry are dead, so skip the
119 : * check.
120 : */
121 0 : ExecDropSingleTupleTableSlot(slot);
122 0 : table_index_fetch_end(scan);
123 0 : return PointerGetDatum(NULL);
124 : }
125 122 : table_index_fetch_end(scan);
126 : }
127 :
128 : /*
129 : * Open the index, acquiring a RowExclusiveLock, just as if we were going
130 : * to update it. (This protects against possible changes of the index
131 : * schema, not against concurrent updates.)
132 : */
133 122 : indexRel = index_open(trigdata->tg_trigger->tgconstrindid,
134 : RowExclusiveLock);
135 122 : indexInfo = BuildIndexInfo(indexRel);
136 :
137 : /*
138 : * Typically the index won't have expressions, but if it does we need an
139 : * EState to evaluate them. We need it for exclusion constraints too,
140 : * even if they are just on simple columns.
141 : */
142 122 : if (indexInfo->ii_Expressions != NIL ||
143 122 : indexInfo->ii_ExclusionOps != NULL)
144 : {
145 24 : estate = CreateExecutorState();
146 24 : econtext = GetPerTupleExprContext(estate);
147 24 : econtext->ecxt_scantuple = slot;
148 : }
149 : else
150 98 : estate = NULL;
151 :
152 : /*
153 : * Form the index values and isnull flags for the index entry that we need
154 : * to check.
155 : *
156 : * Note: if the index uses functions that are not as immutable as they are
157 : * supposed to be, this could produce an index tuple different from the
158 : * original. The index AM can catch such errors by verifying that it
159 : * finds a matching index entry with the tuple's TID. For exclusion
160 : * constraints we check this in check_exclusion_constraint().
161 : */
162 122 : FormIndexDatum(indexInfo, slot, estate, values, isnull);
163 :
164 : /*
165 : * Now do the appropriate check.
166 : */
167 122 : if (indexInfo->ii_ExclusionOps == NULL)
168 : {
169 : /*
170 : * Note: this is not a real insert; it is a check that the index entry
171 : * that has already been inserted is unique. Passing the tuple's tid
172 : * (i.e. unmodified by table_index_fetch_tuple()) is correct even if
173 : * the row is now dead, because that is the TID the index will know
174 : * about.
175 : */
176 98 : index_insert(indexRel, values, isnull, &checktid,
177 : trigdata->tg_relation, UNIQUE_CHECK_EXISTING,
178 : false, indexInfo);
179 : }
180 : else
181 : {
182 : /*
183 : * For exclusion constraints we just do the normal check, but now it's
184 : * okay to throw error. In the HOT-update case, we must use the live
185 : * HOT child's TID here, else check_exclusion_constraint will think
186 : * the child is a conflict.
187 : */
188 24 : check_exclusion_constraint(trigdata->tg_relation, indexRel, indexInfo,
189 : &tmptid, values, isnull,
190 : estate, false);
191 : }
192 :
193 : /*
194 : * If that worked, then this index entry is unique or non-excluded, and we
195 : * are done.
196 : */
197 60 : if (estate != NULL)
198 6 : FreeExecutorState(estate);
199 :
200 60 : ExecDropSingleTupleTableSlot(slot);
201 :
202 60 : index_close(indexRel, RowExclusiveLock);
203 :
204 60 : return PointerGetDatum(NULL);
205 : }
|
