1/*-------------------------------------------------------------------------
2 *
3 * constraint.c
4 * PostgreSQL CONSTRAINT support code.
5 *
6 * Portions Copyright (c) 1996-2019, 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 */
40Datum
41unique_key_recheck(PG_FUNCTION_ARGS)
42{
43 TriggerData *trigdata = castNode(TriggerData, fcinfo->context);
44 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 if (!CALLED_AS_TRIGGER(fcinfo))
61 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 if (!TRIGGER_FIRED_AFTER(trigdata->tg_event) ||
67 !TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
68 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 if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
77 checktid = trigdata->tg_trigslot->tts_tid;
78 else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
79 checktid = trigdata->tg_newslot->tts_tid;
80 else
81 {
82 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 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 tmptid = checktid;
110 {
111 IndexFetchTableData *scan = table_index_fetch_begin(trigdata->tg_relation);
112 bool call_again = false;
113
114 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 ExecDropSingleTupleTableSlot(slot);
122 table_index_fetch_end(scan);
123 return PointerGetDatum(NULL);
124 }
125 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 indexRel = index_open(trigdata->tg_trigger->tgconstrindid,
134 RowExclusiveLock);
135 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 if (indexInfo->ii_Expressions != NIL ||
143 indexInfo->ii_ExclusionOps != NULL)
144 {
145 estate = CreateExecutorState();
146 econtext = GetPerTupleExprContext(estate);
147 econtext->ecxt_scantuple = slot;
148 }
149 else
150 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 FormIndexDatum(indexInfo, slot, estate, values, isnull);
163
164 /*
165 * Now do the appropriate check.
166 */
167 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 index_insert(indexRel, values, isnull, &checktid,
177 trigdata->tg_relation, UNIQUE_CHECK_EXISTING,
178 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 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 if (estate != NULL)
198 FreeExecutorState(estate);
199
200 ExecDropSingleTupleTableSlot(slot);
201
202 index_close(indexRel, RowExclusiveLock);
203
204 return PointerGetDatum(NULL);
205}
206