Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * execIndexing.c
4 : * routines for inserting index tuples and enforcing unique and
5 : * exclusion constraints.
6 : *
7 : * ExecInsertIndexTuples() is the main entry point. It's called after
8 : * inserting a tuple to the heap, and it inserts corresponding index tuples
9 : * into all indexes. At the same time, it enforces any unique and
10 : * exclusion constraints:
11 : *
12 : * Unique Indexes
13 : * --------------
14 : *
15 : * Enforcing a unique constraint is straightforward. When the index AM
16 : * inserts the tuple to the index, it also checks that there are no
17 : * conflicting tuples in the index already. It does so atomically, so that
18 : * even if two backends try to insert the same key concurrently, only one
19 : * of them will succeed. All the logic to ensure atomicity, and to wait
20 : * for in-progress transactions to finish, is handled by the index AM.
21 : *
22 : * If a unique constraint is deferred, we request the index AM to not
23 : * throw an error if a conflict is found. Instead, we make note that there
24 : * was a conflict and return the list of indexes with conflicts to the
25 : * caller. The caller must re-check them later, by calling index_insert()
26 : * with the UNIQUE_CHECK_EXISTING option.
27 : *
28 : * Exclusion Constraints
29 : * ---------------------
30 : *
31 : * Exclusion constraints are different from unique indexes in that when the
32 : * tuple is inserted to the index, the index AM does not check for
33 : * duplicate keys at the same time. After the insertion, we perform a
34 : * separate scan on the index to check for conflicting tuples, and if one
35 : * is found, we throw an error and the transaction is aborted. If the
36 : * conflicting tuple's inserter or deleter is in-progress, we wait for it
37 : * to finish first.
38 : *
39 : * There is a chance of deadlock, if two backends insert a tuple at the
40 : * same time, and then perform the scan to check for conflicts. They will
41 : * find each other's tuple, and both try to wait for each other. The
42 : * deadlock detector will detect that, and abort one of the transactions.
43 : * That's fairly harmless, as one of them was bound to abort with a
44 : * "duplicate key error" anyway, although you get a different error
45 : * message.
46 : *
47 : * If an exclusion constraint is deferred, we still perform the conflict
48 : * checking scan immediately after inserting the index tuple. But instead
49 : * of throwing an error if a conflict is found, we return that information
50 : * to the caller. The caller must re-check them later by calling
51 : * check_exclusion_constraint().
52 : *
53 : * Speculative insertion
54 : * ---------------------
55 : *
56 : * Speculative insertion is a two-phase mechanism used to implement
57 : * INSERT ... ON CONFLICT DO UPDATE/NOTHING. The tuple is first inserted
58 : * to the heap and update the indexes as usual, but if a constraint is
59 : * violated, we can still back out the insertion without aborting the whole
60 : * transaction. In an INSERT ... ON CONFLICT statement, if a conflict is
61 : * detected, the inserted tuple is backed out and the ON CONFLICT action is
62 : * executed instead.
63 : *
64 : * Insertion to a unique index works as usual: the index AM checks for
65 : * duplicate keys atomically with the insertion. But instead of throwing
66 : * an error on a conflict, the speculatively inserted heap tuple is backed
67 : * out.
68 : *
69 : * Exclusion constraints are slightly more complicated. As mentioned
70 : * earlier, there is a risk of deadlock when two backends insert the same
71 : * key concurrently. That was not a problem for regular insertions, when
72 : * one of the transactions has to be aborted anyway, but with a speculative
73 : * insertion we cannot let a deadlock happen, because we only want to back
74 : * out the speculatively inserted tuple on conflict, not abort the whole
75 : * transaction.
76 : *
77 : * When a backend detects that the speculative insertion conflicts with
78 : * another in-progress tuple, it has two options:
79 : *
80 : * 1. back out the speculatively inserted tuple, then wait for the other
81 : * transaction, and retry. Or,
82 : * 2. wait for the other transaction, with the speculatively inserted tuple
83 : * still in place.
84 : *
85 : * If two backends insert at the same time, and both try to wait for each
86 : * other, they will deadlock. So option 2 is not acceptable. Option 1
87 : * avoids the deadlock, but it is prone to a livelock instead. Both
88 : * transactions will wake up immediately as the other transaction backs
89 : * out. Then they both retry, and conflict with each other again, lather,
90 : * rinse, repeat.
91 : *
92 : * To avoid the livelock, one of the backends must back out first, and then
93 : * wait, while the other one waits without backing out. It doesn't matter
94 : * which one backs out, so we employ an arbitrary rule that the transaction
95 : * with the higher XID backs out.
96 : *
97 : *
98 : * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
99 : * Portions Copyright (c) 1994, Regents of the University of California
100 : *
101 : *
102 : * IDENTIFICATION
103 : * src/backend/executor/execIndexing.c
104 : *
105 : *-------------------------------------------------------------------------
106 : */
107 : #include "postgres.h"
108 :
109 : #include "access/genam.h"
110 : #include "access/relscan.h"
111 : #include "access/tableam.h"
112 : #include "access/xact.h"
113 : #include "catalog/index.h"
114 : #include "executor/executor.h"
115 : #include "nodes/nodeFuncs.h"
116 : #include "storage/lmgr.h"
117 : #include "utils/snapmgr.h"
118 :
119 : /* waitMode argument to check_exclusion_or_unique_constraint() */
120 : typedef enum
121 : {
122 : CEOUC_WAIT,
123 : CEOUC_NOWAIT,
124 : CEOUC_LIVELOCK_PREVENTING_WAIT
125 : } CEOUC_WAIT_MODE;
126 :
127 : static bool check_exclusion_or_unique_constraint(Relation heap, Relation index,
128 : IndexInfo *indexInfo,
129 : ItemPointer tupleid,
130 : Datum *values, bool *isnull,
131 : EState *estate, bool newIndex,
132 : CEOUC_WAIT_MODE waitMode,
133 : bool violationOK,
134 : ItemPointer conflictTid);
135 :
136 : static bool index_recheck_constraint(Relation index, Oid *constr_procs,
137 : Datum *existing_values, bool *existing_isnull,
138 : Datum *new_values);
139 : static bool index_unchanged_by_update(ResultRelInfo *resultRelInfo,
140 : EState *estate, IndexInfo *indexInfo,
141 : Relation indexRelation);
142 : static bool index_expression_changed_walker(Node *node,
143 : Bitmapset *allUpdatedCols);
144 :
145 : /* ----------------------------------------------------------------
146 : * ExecOpenIndices
147 : *
148 : * Find the indices associated with a result relation, open them,
149 : * and save information about them in the result ResultRelInfo.
150 : *
151 : * At entry, caller has already opened and locked
152 : * resultRelInfo->ri_RelationDesc.
153 : * ----------------------------------------------------------------
154 : */
155 : void
156 4287152 : ExecOpenIndices(ResultRelInfo *resultRelInfo, bool speculative)
157 : {
158 4287152 : Relation resultRelation = resultRelInfo->ri_RelationDesc;
159 : List *indexoidlist;
160 : ListCell *l;
161 : int len,
162 : i;
163 : RelationPtr relationDescs;
164 : IndexInfo **indexInfoArray;
165 :
166 4287152 : resultRelInfo->ri_NumIndices = 0;
167 :
168 : /* fast path if no indexes */
169 4287152 : if (!RelationGetForm(resultRelation)->relhasindex)
170 482370 : return;
171 :
172 : /*
173 : * Get cached list of index OIDs
174 : */
175 3804782 : indexoidlist = RelationGetIndexList(resultRelation);
176 3804782 : len = list_length(indexoidlist);
177 3804782 : if (len == 0)
178 40686 : return;
179 :
180 : /*
181 : * allocate space for result arrays
182 : */
183 3764096 : relationDescs = (RelationPtr) palloc(len * sizeof(Relation));
184 3764096 : indexInfoArray = (IndexInfo **) palloc(len * sizeof(IndexInfo *));
185 :
186 3764096 : resultRelInfo->ri_NumIndices = len;
187 3764096 : resultRelInfo->ri_IndexRelationDescs = relationDescs;
188 3764096 : resultRelInfo->ri_IndexRelationInfo = indexInfoArray;
189 :
190 : /*
191 : * For each index, open the index relation and save pg_index info. We
192 : * acquire RowExclusiveLock, signifying we will update the index.
193 : *
194 : * Note: we do this even if the index is not indisready; it's not worth
195 : * the trouble to optimize for the case where it isn't.
196 : */
197 3764096 : i = 0;
198 11053456 : foreach(l, indexoidlist)
199 : {
200 7289360 : Oid indexOid = lfirst_oid(l);
201 : Relation indexDesc;
202 : IndexInfo *ii;
203 :
204 7289360 : indexDesc = index_open(indexOid, RowExclusiveLock);
205 :
206 : /* extract index key information from the index's pg_index info */
207 7289360 : ii = BuildIndexInfo(indexDesc);
208 :
209 : /*
210 : * If the indexes are to be used for speculative insertion, add extra
211 : * information required by unique index entries.
212 : */
213 7289360 : if (speculative && ii->ii_Unique)
214 1206 : BuildSpeculativeIndexInfo(indexDesc, ii);
215 :
216 7289360 : relationDescs[i] = indexDesc;
217 7289360 : indexInfoArray[i] = ii;
218 7289360 : i++;
219 : }
220 :
221 3764096 : list_free(indexoidlist);
222 : }
223 :
224 : /* ----------------------------------------------------------------
225 : * ExecCloseIndices
226 : *
227 : * Close the index relations stored in resultRelInfo
228 : * ----------------------------------------------------------------
229 : */
230 : void
231 4390238 : ExecCloseIndices(ResultRelInfo *resultRelInfo)
232 : {
233 : int i;
234 : int numIndices;
235 : RelationPtr indexDescs;
236 :
237 4390238 : numIndices = resultRelInfo->ri_NumIndices;
238 4390238 : indexDescs = resultRelInfo->ri_IndexRelationDescs;
239 :
240 11678092 : for (i = 0; i < numIndices; i++)
241 : {
242 7287854 : if (indexDescs[i] == NULL)
243 0 : continue; /* shouldn't happen? */
244 :
245 : /* Drop lock acquired by ExecOpenIndices */
246 7287854 : index_close(indexDescs[i], RowExclusiveLock);
247 : }
248 :
249 : /*
250 : * XXX should free indexInfo array here too? Currently we assume that
251 : * such stuff will be cleaned up automatically in FreeExecutorState.
252 : */
253 4390238 : }
254 :
255 : /* ----------------------------------------------------------------
256 : * ExecInsertIndexTuples
257 : *
258 : * This routine takes care of inserting index tuples
259 : * into all the relations indexing the result relation
260 : * when a heap tuple is inserted into the result relation.
261 : *
262 : * When 'update' is true and 'onlySummarizing' is false,
263 : * executor is performing an UPDATE that could not use an
264 : * optimization like heapam's HOT (in more general terms a
265 : * call to table_tuple_update() took place and set
266 : * 'update_indexes' to TUUI_All). Receiving this hint makes
267 : * us consider if we should pass down the 'indexUnchanged'
268 : * hint in turn. That's something that we figure out for
269 : * each index_insert() call iff 'update' is true.
270 : * (When 'update' is false we already know not to pass the
271 : * hint to any index.)
272 : *
273 : * If onlySummarizing is set, an equivalent optimization to
274 : * HOT has been applied and any updated columns are indexed
275 : * only by summarizing indexes (or in more general terms a
276 : * call to table_tuple_update() took place and set
277 : * 'update_indexes' to TUUI_Summarizing). We can (and must)
278 : * therefore only update the indexes that have
279 : * 'amsummarizing' = true.
280 : *
281 : * Unique and exclusion constraints are enforced at the same
282 : * time. This returns a list of index OIDs for any unique or
283 : * exclusion constraints that are deferred and that had
284 : * potential (unconfirmed) conflicts. (if noDupErr == true,
285 : * the same is done for non-deferred constraints, but report
286 : * if conflict was speculative or deferred conflict to caller)
287 : *
288 : * If 'arbiterIndexes' is nonempty, noDupErr applies only to
289 : * those indexes. NIL means noDupErr applies to all indexes.
290 : * ----------------------------------------------------------------
291 : */
292 : List *
293 3815006 : ExecInsertIndexTuples(ResultRelInfo *resultRelInfo,
294 : TupleTableSlot *slot,
295 : EState *estate,
296 : bool update,
297 : bool noDupErr,
298 : bool *specConflict,
299 : List *arbiterIndexes,
300 : bool onlySummarizing)
301 : {
302 3815006 : ItemPointer tupleid = &slot->tts_tid;
303 3815006 : List *result = NIL;
304 : int i;
305 : int numIndices;
306 : RelationPtr relationDescs;
307 : Relation heapRelation;
308 : IndexInfo **indexInfoArray;
309 : ExprContext *econtext;
310 : Datum values[INDEX_MAX_KEYS];
311 : bool isnull[INDEX_MAX_KEYS];
312 :
313 : Assert(ItemPointerIsValid(tupleid));
314 :
315 : /*
316 : * Get information from the result relation info structure.
317 : */
318 3815006 : numIndices = resultRelInfo->ri_NumIndices;
319 3815006 : relationDescs = resultRelInfo->ri_IndexRelationDescs;
320 3815006 : indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
321 3815006 : heapRelation = resultRelInfo->ri_RelationDesc;
322 :
323 : /* Sanity check: slot must belong to the same rel as the resultRelInfo. */
324 : Assert(slot->tts_tableOid == RelationGetRelid(heapRelation));
325 :
326 : /*
327 : * We will use the EState's per-tuple context for evaluating predicates
328 : * and index expressions (creating it if it's not already there).
329 : */
330 3815006 : econtext = GetPerTupleExprContext(estate);
331 :
332 : /* Arrange for econtext's scan tuple to be the tuple under test */
333 3815006 : econtext->ecxt_scantuple = slot;
334 :
335 : /*
336 : * for each index, form and insert the index tuple
337 : */
338 8095876 : for (i = 0; i < numIndices; i++)
339 : {
340 4281442 : Relation indexRelation = relationDescs[i];
341 : IndexInfo *indexInfo;
342 : bool applyNoDupErr;
343 : IndexUniqueCheck checkUnique;
344 : bool indexUnchanged;
345 : bool satisfiesConstraint;
346 :
347 4281442 : if (indexRelation == NULL)
348 0 : continue;
349 :
350 4281442 : indexInfo = indexInfoArray[i];
351 :
352 : /* If the index is marked as read-only, ignore it */
353 4281442 : if (!indexInfo->ii_ReadyForInserts)
354 260 : continue;
355 :
356 : /*
357 : * Skip processing of non-summarizing indexes if we only update
358 : * summarizing indexes
359 : */
360 4281182 : if (onlySummarizing && !indexInfo->ii_Summarizing)
361 6 : continue;
362 :
363 : /* Check for partial index */
364 4281176 : if (indexInfo->ii_Predicate != NIL)
365 : {
366 : ExprState *predicate;
367 :
368 : /*
369 : * If predicate state not set up yet, create it (in the estate's
370 : * per-query context)
371 : */
372 401090 : predicate = indexInfo->ii_PredicateState;
373 401090 : if (predicate == NULL)
374 : {
375 260 : predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
376 260 : indexInfo->ii_PredicateState = predicate;
377 : }
378 :
379 : /* Skip this index-update if the predicate isn't satisfied */
380 401090 : if (!ExecQual(predicate, econtext))
381 400548 : continue;
382 : }
383 :
384 : /*
385 : * FormIndexDatum fills in its values and isnull parameters with the
386 : * appropriate values for the column(s) of the index.
387 : */
388 3880628 : FormIndexDatum(indexInfo,
389 : slot,
390 : estate,
391 : values,
392 : isnull);
393 :
394 : /* Check whether to apply noDupErr to this index */
395 3884618 : applyNoDupErr = noDupErr &&
396 3990 : (arbiterIndexes == NIL ||
397 3990 : list_member_oid(arbiterIndexes,
398 3990 : indexRelation->rd_index->indexrelid));
399 :
400 : /*
401 : * The index AM does the actual insertion, plus uniqueness checking.
402 : *
403 : * For an immediate-mode unique index, we just tell the index AM to
404 : * throw error if not unique.
405 : *
406 : * For a deferrable unique index, we tell the index AM to just detect
407 : * possible non-uniqueness, and we add the index OID to the result
408 : * list if further checking is needed.
409 : *
410 : * For a speculative insertion (used by INSERT ... ON CONFLICT), do
411 : * the same as for a deferrable unique index.
412 : */
413 3880628 : if (!indexRelation->rd_index->indisunique)
414 1861762 : checkUnique = UNIQUE_CHECK_NO;
415 2018866 : else if (applyNoDupErr)
416 4032 : checkUnique = UNIQUE_CHECK_PARTIAL;
417 2014834 : else if (indexRelation->rd_index->indimmediate)
418 2014684 : checkUnique = UNIQUE_CHECK_YES;
419 : else
420 150 : checkUnique = UNIQUE_CHECK_PARTIAL;
421 :
422 : /*
423 : * There's definitely going to be an index_insert() call for this
424 : * index. If we're being called as part of an UPDATE statement,
425 : * consider if the 'indexUnchanged' = true hint should be passed.
426 : */
427 3880628 : indexUnchanged = update && index_unchanged_by_update(resultRelInfo,
428 : estate,
429 : indexInfo,
430 : indexRelation);
431 :
432 : satisfiesConstraint =
433 3880628 : index_insert(indexRelation, /* index relation */
434 : values, /* array of index Datums */
435 : isnull, /* null flags */
436 : tupleid, /* tid of heap tuple */
437 : heapRelation, /* heap relation */
438 : checkUnique, /* type of uniqueness check to do */
439 : indexUnchanged, /* UPDATE without logical change? */
440 : indexInfo); /* index AM may need this */
441 :
442 : /*
443 : * If the index has an associated exclusion constraint, check that.
444 : * This is simpler than the process for uniqueness checks since we
445 : * always insert first and then check. If the constraint is deferred,
446 : * we check now anyway, but don't throw error on violation or wait for
447 : * a conclusive outcome from a concurrent insertion; instead we'll
448 : * queue a recheck event. Similarly, noDupErr callers (speculative
449 : * inserters) will recheck later, and wait for a conclusive outcome
450 : * then.
451 : *
452 : * An index for an exclusion constraint can't also be UNIQUE (not an
453 : * essential property, we just don't allow it in the grammar), so no
454 : * need to preserve the prior state of satisfiesConstraint.
455 : */
456 3880106 : if (indexInfo->ii_ExclusionOps != NULL)
457 : {
458 : bool violationOK;
459 : CEOUC_WAIT_MODE waitMode;
460 :
461 306 : if (applyNoDupErr)
462 : {
463 0 : violationOK = true;
464 0 : waitMode = CEOUC_LIVELOCK_PREVENTING_WAIT;
465 : }
466 306 : else if (!indexRelation->rd_index->indimmediate)
467 : {
468 42 : violationOK = true;
469 42 : waitMode = CEOUC_NOWAIT;
470 : }
471 : else
472 : {
473 264 : violationOK = false;
474 264 : waitMode = CEOUC_WAIT;
475 : }
476 :
477 : satisfiesConstraint =
478 306 : check_exclusion_or_unique_constraint(heapRelation,
479 : indexRelation, indexInfo,
480 : tupleid, values, isnull,
481 : estate, false,
482 : waitMode, violationOK, NULL);
483 : }
484 :
485 3880056 : if ((checkUnique == UNIQUE_CHECK_PARTIAL ||
486 3875874 : indexInfo->ii_ExclusionOps != NULL) &&
487 4438 : !satisfiesConstraint)
488 : {
489 : /*
490 : * The tuple potentially violates the uniqueness or exclusion
491 : * constraint, so make a note of the index so that we can re-check
492 : * it later. Speculative inserters are told if there was a
493 : * speculative conflict, since that always requires a restart.
494 : */
495 132 : result = lappend_oid(result, RelationGetRelid(indexRelation));
496 132 : if (indexRelation->rd_index->indimmediate && specConflict)
497 10 : *specConflict = true;
498 : }
499 : }
500 :
501 3814434 : return result;
502 : }
503 :
504 : /* ----------------------------------------------------------------
505 : * ExecCheckIndexConstraints
506 : *
507 : * This routine checks if a tuple violates any unique or
508 : * exclusion constraints. Returns true if there is no conflict.
509 : * Otherwise returns false, and the TID of the conflicting
510 : * tuple is returned in *conflictTid.
511 : *
512 : * If 'arbiterIndexes' is given, only those indexes are checked.
513 : * NIL means all indexes.
514 : *
515 : * Note that this doesn't lock the values in any way, so it's
516 : * possible that a conflicting tuple is inserted immediately
517 : * after this returns. But this can be used for a pre-check
518 : * before insertion.
519 : * ----------------------------------------------------------------
520 : */
521 : bool
522 9390 : ExecCheckIndexConstraints(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
523 : EState *estate, ItemPointer conflictTid,
524 : List *arbiterIndexes)
525 : {
526 : int i;
527 : int numIndices;
528 : RelationPtr relationDescs;
529 : Relation heapRelation;
530 : IndexInfo **indexInfoArray;
531 : ExprContext *econtext;
532 : Datum values[INDEX_MAX_KEYS];
533 : bool isnull[INDEX_MAX_KEYS];
534 : ItemPointerData invalidItemPtr;
535 9390 : bool checkedIndex = false;
536 :
537 9390 : ItemPointerSetInvalid(conflictTid);
538 9390 : ItemPointerSetInvalid(&invalidItemPtr);
539 :
540 : /*
541 : * Get information from the result relation info structure.
542 : */
543 9390 : numIndices = resultRelInfo->ri_NumIndices;
544 9390 : relationDescs = resultRelInfo->ri_IndexRelationDescs;
545 9390 : indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
546 9390 : heapRelation = resultRelInfo->ri_RelationDesc;
547 :
548 : /*
549 : * We will use the EState's per-tuple context for evaluating predicates
550 : * and index expressions (creating it if it's not already there).
551 : */
552 9390 : econtext = GetPerTupleExprContext(estate);
553 :
554 : /* Arrange for econtext's scan tuple to be the tuple under test */
555 9390 : econtext->ecxt_scantuple = slot;
556 :
557 : /*
558 : * For each index, form index tuple and check if it satisfies the
559 : * constraint.
560 : */
561 13504 : for (i = 0; i < numIndices; i++)
562 : {
563 9478 : Relation indexRelation = relationDescs[i];
564 : IndexInfo *indexInfo;
565 : bool satisfiesConstraint;
566 :
567 9478 : if (indexRelation == NULL)
568 0 : continue;
569 :
570 9478 : indexInfo = indexInfoArray[i];
571 :
572 9478 : if (!indexInfo->ii_Unique && !indexInfo->ii_ExclusionOps)
573 4 : continue;
574 :
575 : /* If the index is marked as read-only, ignore it */
576 9474 : if (!indexInfo->ii_ReadyForInserts)
577 0 : continue;
578 :
579 : /* When specific arbiter indexes requested, only examine them */
580 9474 : if (arbiterIndexes != NIL &&
581 9294 : !list_member_oid(arbiterIndexes,
582 9294 : indexRelation->rd_index->indexrelid))
583 78 : continue;
584 :
585 9396 : if (!indexRelation->rd_index->indimmediate)
586 6 : ereport(ERROR,
587 : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
588 : errmsg("ON CONFLICT does not support deferrable unique constraints/exclusion constraints as arbiters"),
589 : errtableconstraint(heapRelation,
590 : RelationGetRelationName(indexRelation))));
591 :
592 9390 : checkedIndex = true;
593 :
594 : /* Check for partial index */
595 9390 : if (indexInfo->ii_Predicate != NIL)
596 : {
597 : ExprState *predicate;
598 :
599 : /*
600 : * If predicate state not set up yet, create it (in the estate's
601 : * per-query context)
602 : */
603 30 : predicate = indexInfo->ii_PredicateState;
604 30 : if (predicate == NULL)
605 : {
606 30 : predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
607 30 : indexInfo->ii_PredicateState = predicate;
608 : }
609 :
610 : /* Skip this index-update if the predicate isn't satisfied */
611 30 : if (!ExecQual(predicate, econtext))
612 0 : continue;
613 : }
614 :
615 : /*
616 : * FormIndexDatum fills in its values and isnull parameters with the
617 : * appropriate values for the column(s) of the index.
618 : */
619 9390 : FormIndexDatum(indexInfo,
620 : slot,
621 : estate,
622 : values,
623 : isnull);
624 :
625 : satisfiesConstraint =
626 9390 : check_exclusion_or_unique_constraint(heapRelation, indexRelation,
627 : indexInfo, &invalidItemPtr,
628 : values, isnull, estate, false,
629 : CEOUC_WAIT, true,
630 : conflictTid);
631 9390 : if (!satisfiesConstraint)
632 5358 : return false;
633 : }
634 :
635 4026 : if (arbiterIndexes != NIL && !checkedIndex)
636 0 : elog(ERROR, "unexpected failure to find arbiter index");
637 :
638 4026 : return true;
639 : }
640 :
641 : /*
642 : * Check for violation of an exclusion or unique constraint
643 : *
644 : * heap: the table containing the new tuple
645 : * index: the index supporting the constraint
646 : * indexInfo: info about the index, including the exclusion properties
647 : * tupleid: heap TID of the new tuple we have just inserted (invalid if we
648 : * haven't inserted a new tuple yet)
649 : * values, isnull: the *index* column values computed for the new tuple
650 : * estate: an EState we can do evaluation in
651 : * newIndex: if true, we are trying to build a new index (this affects
652 : * only the wording of error messages)
653 : * waitMode: whether to wait for concurrent inserters/deleters
654 : * violationOK: if true, don't throw error for violation
655 : * conflictTid: if not-NULL, the TID of the conflicting tuple is returned here
656 : *
657 : * Returns true if OK, false if actual or potential violation
658 : *
659 : * 'waitMode' determines what happens if a conflict is detected with a tuple
660 : * that was inserted or deleted by a transaction that's still running.
661 : * CEOUC_WAIT means that we wait for the transaction to commit, before
662 : * throwing an error or returning. CEOUC_NOWAIT means that we report the
663 : * violation immediately; so the violation is only potential, and the caller
664 : * must recheck sometime later. This behavior is convenient for deferred
665 : * exclusion checks; we need not bother queuing a deferred event if there is
666 : * definitely no conflict at insertion time.
667 : *
668 : * CEOUC_LIVELOCK_PREVENTING_WAIT is like CEOUC_NOWAIT, but we will sometimes
669 : * wait anyway, to prevent livelocking if two transactions try inserting at
670 : * the same time. This is used with speculative insertions, for INSERT ON
671 : * CONFLICT statements. (See notes in file header)
672 : *
673 : * If violationOK is true, we just report the potential or actual violation to
674 : * the caller by returning 'false'. Otherwise we throw a descriptive error
675 : * message here. When violationOK is false, a false result is impossible.
676 : *
677 : * Note: The indexam is normally responsible for checking unique constraints,
678 : * so this normally only needs to be used for exclusion constraints. But this
679 : * function is also called when doing a "pre-check" for conflicts on a unique
680 : * constraint, when doing speculative insertion. Caller may use the returned
681 : * conflict TID to take further steps.
682 : */
683 : static bool
684 9766 : check_exclusion_or_unique_constraint(Relation heap, Relation index,
685 : IndexInfo *indexInfo,
686 : ItemPointer tupleid,
687 : Datum *values, bool *isnull,
688 : EState *estate, bool newIndex,
689 : CEOUC_WAIT_MODE waitMode,
690 : bool violationOK,
691 : ItemPointer conflictTid)
692 : {
693 : Oid *constr_procs;
694 : uint16 *constr_strats;
695 9766 : Oid *index_collations = index->rd_indcollation;
696 9766 : int indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
697 : IndexScanDesc index_scan;
698 : ScanKeyData scankeys[INDEX_MAX_KEYS];
699 : SnapshotData DirtySnapshot;
700 : int i;
701 : bool conflict;
702 : bool found_self;
703 : ExprContext *econtext;
704 : TupleTableSlot *existing_slot;
705 : TupleTableSlot *save_scantuple;
706 :
707 9766 : if (indexInfo->ii_ExclusionOps)
708 : {
709 388 : constr_procs = indexInfo->ii_ExclusionProcs;
710 388 : constr_strats = indexInfo->ii_ExclusionStrats;
711 : }
712 : else
713 : {
714 9378 : constr_procs = indexInfo->ii_UniqueProcs;
715 9378 : constr_strats = indexInfo->ii_UniqueStrats;
716 : }
717 :
718 : /*
719 : * If any of the input values are NULL, and the index uses the default
720 : * nulls-are-distinct mode, the constraint check is assumed to pass (i.e.,
721 : * we assume the operators are strict). Otherwise, we interpret the
722 : * constraint as specifying IS NULL for each column whose input value is
723 : * NULL.
724 : */
725 9766 : if (!indexInfo->ii_NullsNotDistinct)
726 : {
727 19696 : for (i = 0; i < indnkeyatts; i++)
728 : {
729 9936 : if (isnull[i])
730 0 : return true;
731 : }
732 : }
733 :
734 : /*
735 : * Search the tuples that are in the index for any violations, including
736 : * tuples that aren't visible yet.
737 : */
738 9766 : InitDirtySnapshot(DirtySnapshot);
739 :
740 19708 : for (i = 0; i < indnkeyatts; i++)
741 : {
742 9942 : ScanKeyEntryInitialize(&scankeys[i],
743 9942 : isnull[i] ? SK_ISNULL | SK_SEARCHNULL : 0,
744 9942 : i + 1,
745 9942 : constr_strats[i],
746 : InvalidOid,
747 9942 : index_collations[i],
748 9942 : constr_procs[i],
749 9942 : values[i]);
750 : }
751 :
752 : /*
753 : * Need a TupleTableSlot to put existing tuples in.
754 : *
755 : * To use FormIndexDatum, we have to make the econtext's scantuple point
756 : * to this slot. Be sure to save and restore caller's value for
757 : * scantuple.
758 : */
759 9766 : existing_slot = table_slot_create(heap, NULL);
760 :
761 9766 : econtext = GetPerTupleExprContext(estate);
762 9766 : save_scantuple = econtext->ecxt_scantuple;
763 9766 : econtext->ecxt_scantuple = existing_slot;
764 :
765 : /*
766 : * May have to restart scan from this point if a potential conflict is
767 : * found.
768 : */
769 9836 : retry:
770 9836 : conflict = false;
771 9836 : found_self = false;
772 9836 : index_scan = index_beginscan(heap, index, &DirtySnapshot, indnkeyatts, 0);
773 9836 : index_rescan(index_scan, scankeys, indnkeyatts, NULL, 0);
774 :
775 10168 : while (index_getnext_slot(index_scan, ForwardScanDirection, existing_slot))
776 : {
777 : TransactionId xwait;
778 : XLTW_Oper reason_wait;
779 : Datum existing_values[INDEX_MAX_KEYS];
780 : bool existing_isnull[INDEX_MAX_KEYS];
781 : char *error_new;
782 : char *error_existing;
783 :
784 : /*
785 : * Ignore the entry for the tuple we're trying to check.
786 : */
787 6300 : if (ItemPointerIsValid(tupleid) &&
788 436 : ItemPointerEquals(tupleid, &existing_slot->tts_tid))
789 : {
790 278 : if (found_self) /* should not happen */
791 0 : elog(ERROR, "found self tuple multiple times in index \"%s\"",
792 : RelationGetRelationName(index));
793 278 : found_self = true;
794 332 : continue;
795 : }
796 :
797 : /*
798 : * Extract the index column values and isnull flags from the existing
799 : * tuple.
800 : */
801 5586 : FormIndexDatum(indexInfo, existing_slot, estate,
802 : existing_values, existing_isnull);
803 :
804 : /* If lossy indexscan, must recheck the condition */
805 5586 : if (index_scan->xs_recheck)
806 : {
807 72 : if (!index_recheck_constraint(index,
808 : constr_procs,
809 : existing_values,
810 : existing_isnull,
811 : values))
812 54 : continue; /* tuple doesn't actually match, so no
813 : * conflict */
814 : }
815 :
816 : /*
817 : * At this point we have either a conflict or a potential conflict.
818 : *
819 : * If an in-progress transaction is affecting the visibility of this
820 : * tuple, we need to wait for it to complete and then recheck (unless
821 : * the caller requested not to). For simplicity we do rechecking by
822 : * just restarting the whole scan --- this case probably doesn't
823 : * happen often enough to be worth trying harder, and anyway we don't
824 : * want to hold any index internal locks while waiting.
825 : */
826 11064 : xwait = TransactionIdIsValid(DirtySnapshot.xmin) ?
827 5532 : DirtySnapshot.xmin : DirtySnapshot.xmax;
828 :
829 5532 : if (TransactionIdIsValid(xwait) &&
830 0 : (waitMode == CEOUC_WAIT ||
831 0 : (waitMode == CEOUC_LIVELOCK_PREVENTING_WAIT &&
832 0 : DirtySnapshot.speculativeToken &&
833 0 : TransactionIdPrecedes(GetCurrentTransactionId(), xwait))))
834 : {
835 140 : reason_wait = indexInfo->ii_ExclusionOps ?
836 70 : XLTW_RecheckExclusionConstr : XLTW_InsertIndex;
837 70 : index_endscan(index_scan);
838 70 : if (DirtySnapshot.speculativeToken)
839 2 : SpeculativeInsertionWait(DirtySnapshot.xmin,
840 : DirtySnapshot.speculativeToken);
841 : else
842 68 : XactLockTableWait(xwait, heap,
843 : &existing_slot->tts_tid, reason_wait);
844 70 : goto retry;
845 : }
846 :
847 : /*
848 : * We have a definite conflict (or a potential one, but the caller
849 : * didn't want to wait). Return it to caller, or report it.
850 : */
851 5462 : if (violationOK)
852 : {
853 5382 : conflict = true;
854 5382 : if (conflictTid)
855 5358 : *conflictTid = existing_slot->tts_tid;
856 5382 : break;
857 : }
858 :
859 80 : error_new = BuildIndexValueDescription(index, values, isnull);
860 80 : error_existing = BuildIndexValueDescription(index, existing_values,
861 : existing_isnull);
862 80 : if (newIndex)
863 12 : ereport(ERROR,
864 : (errcode(ERRCODE_EXCLUSION_VIOLATION),
865 : errmsg("could not create exclusion constraint \"%s\"",
866 : RelationGetRelationName(index)),
867 : error_new && error_existing ?
868 : errdetail("Key %s conflicts with key %s.",
869 : error_new, error_existing) :
870 : errdetail("Key conflicts exist."),
871 : errtableconstraint(heap,
872 : RelationGetRelationName(index))));
873 : else
874 68 : ereport(ERROR,
875 : (errcode(ERRCODE_EXCLUSION_VIOLATION),
876 : errmsg("conflicting key value violates exclusion constraint \"%s\"",
877 : RelationGetRelationName(index)),
878 : error_new && error_existing ?
879 : errdetail("Key %s conflicts with existing key %s.",
880 : error_new, error_existing) :
881 : errdetail("Key conflicts with existing key."),
882 : errtableconstraint(heap,
883 : RelationGetRelationName(index))));
884 : }
885 :
886 9686 : index_endscan(index_scan);
887 :
888 : /*
889 : * Ordinarily, at this point the search should have found the originally
890 : * inserted tuple (if any), unless we exited the loop early because of
891 : * conflict. However, it is possible to define exclusion constraints for
892 : * which that wouldn't be true --- for instance, if the operator is <>. So
893 : * we no longer complain if found_self is still false.
894 : */
895 :
896 9686 : econtext->ecxt_scantuple = save_scantuple;
897 :
898 9686 : ExecDropSingleTupleTableSlot(existing_slot);
899 :
900 9686 : return !conflict;
901 : }
902 :
903 : /*
904 : * Check for violation of an exclusion constraint
905 : *
906 : * This is a dumbed down version of check_exclusion_or_unique_constraint
907 : * for external callers. They don't need all the special modes.
908 : */
909 : void
910 70 : check_exclusion_constraint(Relation heap, Relation index,
911 : IndexInfo *indexInfo,
912 : ItemPointer tupleid,
913 : Datum *values, bool *isnull,
914 : EState *estate, bool newIndex)
915 : {
916 70 : (void) check_exclusion_or_unique_constraint(heap, index, indexInfo, tupleid,
917 : values, isnull,
918 : estate, newIndex,
919 : CEOUC_WAIT, false, NULL);
920 40 : }
921 :
922 : /*
923 : * Check existing tuple's index values to see if it really matches the
924 : * exclusion condition against the new_values. Returns true if conflict.
925 : */
926 : static bool
927 72 : index_recheck_constraint(Relation index, Oid *constr_procs,
928 : Datum *existing_values, bool *existing_isnull,
929 : Datum *new_values)
930 : {
931 72 : int indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
932 : int i;
933 :
934 144 : for (i = 0; i < indnkeyatts; i++)
935 : {
936 : /* Assume the exclusion operators are strict */
937 126 : if (existing_isnull[i])
938 0 : return false;
939 :
940 126 : if (!DatumGetBool(OidFunctionCall2Coll(constr_procs[i],
941 126 : index->rd_indcollation[i],
942 126 : existing_values[i],
943 126 : new_values[i])))
944 54 : return false;
945 : }
946 :
947 18 : return true;
948 : }
949 :
950 : /*
951 : * Check if ExecInsertIndexTuples() should pass indexUnchanged hint.
952 : *
953 : * When the executor performs an UPDATE that requires a new round of index
954 : * tuples, determine if we should pass 'indexUnchanged' = true hint for one
955 : * single index.
956 : */
957 : static bool
958 504452 : index_unchanged_by_update(ResultRelInfo *resultRelInfo, EState *estate,
959 : IndexInfo *indexInfo, Relation indexRelation)
960 : {
961 : Bitmapset *updatedCols;
962 : Bitmapset *extraUpdatedCols;
963 : Bitmapset *allUpdatedCols;
964 504452 : bool hasexpression = false;
965 : List *idxExprs;
966 :
967 : /*
968 : * Check cache first
969 : */
970 504452 : if (indexInfo->ii_CheckedUnchanged)
971 459874 : return indexInfo->ii_IndexUnchanged;
972 44578 : indexInfo->ii_CheckedUnchanged = true;
973 :
974 : /*
975 : * Check for indexed attribute overlap with updated columns.
976 : *
977 : * Only do this for key columns. A change to a non-key column within an
978 : * INCLUDE index should not be counted here. Non-key column values are
979 : * opaque payload state to the index AM, a little like an extra table TID.
980 : *
981 : * Note that row-level BEFORE triggers won't affect our behavior, since
982 : * they don't affect the updatedCols bitmaps generally. It doesn't seem
983 : * worth the trouble of checking which attributes were changed directly.
984 : */
985 44578 : updatedCols = ExecGetUpdatedCols(resultRelInfo, estate);
986 44578 : extraUpdatedCols = ExecGetExtraUpdatedCols(resultRelInfo, estate);
987 49814 : for (int attr = 0; attr < indexInfo->ii_NumIndexKeyAttrs; attr++)
988 : {
989 46654 : int keycol = indexInfo->ii_IndexAttrNumbers[attr];
990 :
991 46654 : if (keycol <= 0)
992 : {
993 : /*
994 : * Skip expressions for now, but remember to deal with them later
995 : * on
996 : */
997 30 : hasexpression = true;
998 30 : continue;
999 : }
1000 :
1001 46624 : if (bms_is_member(keycol - FirstLowInvalidHeapAttributeNumber,
1002 5206 : updatedCols) ||
1003 5206 : bms_is_member(keycol - FirstLowInvalidHeapAttributeNumber,
1004 : extraUpdatedCols))
1005 : {
1006 : /* Changed key column -- don't hint for this index */
1007 41418 : indexInfo->ii_IndexUnchanged = false;
1008 41418 : return false;
1009 : }
1010 : }
1011 :
1012 : /*
1013 : * When we get this far and index has no expressions, return true so that
1014 : * index_insert() call will go on to pass 'indexUnchanged' = true hint.
1015 : *
1016 : * The _absence_ of an indexed key attribute that overlaps with updated
1017 : * attributes (in addition to the total absence of indexed expressions)
1018 : * shows that the index as a whole is logically unchanged by UPDATE.
1019 : */
1020 3160 : if (!hasexpression)
1021 : {
1022 3136 : indexInfo->ii_IndexUnchanged = true;
1023 3136 : return true;
1024 : }
1025 :
1026 : /*
1027 : * Need to pass only one bms to expression_tree_walker helper function.
1028 : * Avoid allocating memory in common case where there are no extra cols.
1029 : */
1030 24 : if (!extraUpdatedCols)
1031 24 : allUpdatedCols = updatedCols;
1032 : else
1033 0 : allUpdatedCols = bms_union(updatedCols, extraUpdatedCols);
1034 :
1035 : /*
1036 : * We have to work slightly harder in the event of indexed expressions,
1037 : * but the principle is the same as before: try to find columns (Vars,
1038 : * actually) that overlap with known-updated columns.
1039 : *
1040 : * If we find any matching Vars, don't pass hint for index. Otherwise
1041 : * pass hint.
1042 : */
1043 24 : idxExprs = RelationGetIndexExpressions(indexRelation);
1044 24 : hasexpression = index_expression_changed_walker((Node *) idxExprs,
1045 : allUpdatedCols);
1046 24 : list_free(idxExprs);
1047 24 : if (extraUpdatedCols)
1048 0 : bms_free(allUpdatedCols);
1049 :
1050 24 : if (hasexpression)
1051 : {
1052 18 : indexInfo->ii_IndexUnchanged = false;
1053 18 : return false;
1054 : }
1055 :
1056 : /*
1057 : * Deliberately don't consider index predicates. We should even give the
1058 : * hint when result rel's "updated tuple" has no corresponding index
1059 : * tuple, which is possible with a partial index (provided the usual
1060 : * conditions are met).
1061 : */
1062 6 : indexInfo->ii_IndexUnchanged = true;
1063 6 : return true;
1064 : }
1065 :
1066 : /*
1067 : * Indexed expression helper for index_unchanged_by_update().
1068 : *
1069 : * Returns true when Var that appears within allUpdatedCols located.
1070 : */
1071 : static bool
1072 76 : index_expression_changed_walker(Node *node, Bitmapset *allUpdatedCols)
1073 : {
1074 76 : if (node == NULL)
1075 0 : return false;
1076 :
1077 76 : if (IsA(node, Var))
1078 : {
1079 24 : Var *var = (Var *) node;
1080 :
1081 24 : if (bms_is_member(var->varattno - FirstLowInvalidHeapAttributeNumber,
1082 : allUpdatedCols))
1083 : {
1084 : /* Var was updated -- indicates that we should not hint */
1085 18 : return true;
1086 : }
1087 :
1088 : /* Still haven't found a reason to not pass the hint */
1089 6 : return false;
1090 : }
1091 :
1092 52 : return expression_tree_walker(node, index_expression_changed_walker,
1093 : (void *) allUpdatedCols);
1094 : }
|
