#include "postgres.h"
#include "access/genam.h"
#include "access/relscan.h"
#include "access/tableam.h"
#include "access/xact.h"
#include "catalog/index.h"
#include "executor/executor.h"
#include "nodes/nodeFuncs.h"
#include "storage/lmgr.h"
#include "utils/snapmgr.h"

Include dependency graph for execIndexing.c:

Enumerations
enum	CEOUC_WAIT_MODE { CEOUC_WAIT, CEOUC_NOWAIT, CEOUC_LIVELOCK_PREVENTING_WAIT }

Functions
static bool	check_exclusion_or_unique_constraint (Relation heap, Relation index, IndexInfo indexInfo, ItemPointer tupleid, Datum values, bool isnull, EState estate, bool newIndex, CEOUC_WAIT_MODE waitMode, bool errorOK, ItemPointer conflictTid)

static bool	index_recheck_constraint (Relation index, Oid constr_procs, Datum existing_values, bool existing_isnull, Datum new_values)

void	ExecOpenIndices (ResultRelInfo *resultRelInfo, bool speculative)

void	ExecCloseIndices (ResultRelInfo *resultRelInfo)

List *	ExecInsertIndexTuples (TupleTableSlot slot, EState estate, bool noDupErr, bool specConflict, List arbiterIndexes)

bool	ExecCheckIndexConstraints (TupleTableSlot slot, EState estate, ItemPointer conflictTid, List *arbiterIndexes)

void	check_exclusion_constraint (Relation heap, Relation index, IndexInfo indexInfo, ItemPointer tupleid, Datum values, bool isnull, EState estate, bool newIndex)

Enumeration Type Documentation

◆ CEOUC_WAIT_MODE

enum CEOUC_WAIT_MODE

Enumerator
CEOUC_WAIT
CEOUC_NOWAIT
CEOUC_LIVELOCK_PREVENTING_WAIT

Definition at line 120 of file execIndexing.c.

 {
     CEOUC_WAIT,
     CEOUC_NOWAIT,
     CEOUC_LIVELOCK_PREVENTING_WAIT
 } CEOUC_WAIT_MODE;

Function Documentation

◆ check_exclusion_constraint()

void check_exclusion_constraint	(	Relation	heap,
		Relation	index,
		IndexInfo *	indexInfo,
		ItemPointer	tupleid,
		Datum *	values,
		bool *	isnull,
		EState *	estate,
		bool	newIndex
	)

Definition at line 866 of file execIndexing.c.

References CEOUC_WAIT, and check_exclusion_or_unique_constraint().

Referenced by exec_rt_fetch(), IndexCheckExclusion(), and unique_key_recheck().

 {
     (void) check_exclusion_or_unique_constraint(heap, index, indexInfo, tupleid,
                                                 values, isnull,
                                                 estate, newIndex,
                                                 CEOUC_WAIT, false, NULL);
 }

◆ check_exclusion_or_unique_constraint()

static bool check_exclusion_or_unique_constraint	(	Relation	heap,
		Relation	index,
		IndexInfo *	indexInfo,
		ItemPointer	tupleid,
		Datum *	values,
		bool *	isnull,
		EState *	estate,
		bool	newIndex,
		CEOUC_WAIT_MODE	waitMode,
		bool	errorOK,
		ItemPointer	conflictTid
	)

static

Definition at line 646 of file execIndexing.c.

References BuildIndexValueDescription(), CEOUC_LIVELOCK_PREVENTING_WAIT, CEOUC_WAIT, ExprContext::ecxt_scantuple, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, errtableconstraint(), ExecDropSingleTupleTableSlot(), FormIndexDatum(), ForwardScanDirection, GetCurrentTransactionId(), GetPerTupleExprContext, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_ExclusionProcs, IndexInfo::ii_ExclusionStrats, IndexInfo::ii_UniqueProcs, IndexInfo::ii_UniqueStrats, index_beginscan(), index_endscan(), index_getnext_slot(), INDEX_MAX_KEYS, index_recheck_constraint(), index_rescan(), IndexRelationGetNumberOfKeyAttributes, InitDirtySnapshot, InvalidOid, ItemPointerEquals(), ItemPointerIsValid, RelationData::rd_indcollation, RelationGetRelationName, ScanKeyEntryInitialize(), SpeculativeInsertionWait(), SnapshotData::speculativeToken, table_slot_create(), TransactionIdIsValid, TransactionIdPrecedes(), TupleTableSlot::tts_tid, XactLockTableWait(), XLTW_InsertIndex, XLTW_RecheckExclusionConstr, SnapshotData::xmax, SnapshotData::xmin, and IndexScanDescData::xs_recheck.

Referenced by check_exclusion_constraint(), ExecCheckIndexConstraints(), and ExecInsertIndexTuples().

 {
     Oid        *constr_procs;
     uint16     *constr_strats;
     Oid        *index_collations = index->rd_indcollation;
     int         indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
     IndexScanDesc index_scan;
     ScanKeyData scankeys[INDEX_MAX_KEYS];
     SnapshotData DirtySnapshot;
     int         i;
     bool        conflict;
     bool        found_self;
     ExprContext *econtext;
     TupleTableSlot *existing_slot;
     TupleTableSlot *save_scantuple;
 
     if (indexInfo->ii_ExclusionOps)
     {
         constr_procs = indexInfo->ii_ExclusionProcs;
         constr_strats = indexInfo->ii_ExclusionStrats;
     }
     else
     {
         constr_procs = indexInfo->ii_UniqueProcs;
         constr_strats = indexInfo->ii_UniqueStrats;
     }
 
     /*
      * If any of the input values are NULL, the constraint check is assumed to
      * pass (i.e., we assume the operators are strict).
      */
     for (i = 0; i < indnkeyatts; i++)
     {
         if (isnull[i])
             return true;
     }
 
     /*
      * Search the tuples that are in the index for any violations, including
      * tuples that aren't visible yet.
      */
     InitDirtySnapshot(DirtySnapshot);
 
     for (i = 0; i < indnkeyatts; i++)
     {
         ScanKeyEntryInitialize(&scankeys[i],
                                0,
                                i + 1,
                                constr_strats[i],
                                InvalidOid,
                                index_collations[i],
                                constr_procs[i],
                                values[i]);
     }
 
     /*
      * Need a TupleTableSlot to put existing tuples in.
      *
      * To use FormIndexDatum, we have to make the econtext's scantuple point
      * to this slot.  Be sure to save and restore caller's value for
      * scantuple.
      */
     existing_slot = table_slot_create(heap, NULL);
 
     econtext = GetPerTupleExprContext(estate);
     save_scantuple = econtext->ecxt_scantuple;
     econtext->ecxt_scantuple = existing_slot;
 
     /*
      * May have to restart scan from this point if a potential conflict is
      * found.
      */
 retry:
     conflict = false;
     found_self = false;
     index_scan = index_beginscan(heap, index, &DirtySnapshot, indnkeyatts, 0);
     index_rescan(index_scan, scankeys, indnkeyatts, NULL, 0);
 
     while (index_getnext_slot(index_scan, ForwardScanDirection, existing_slot))
     {
         TransactionId xwait;
         XLTW_Oper   reason_wait;
         Datum       existing_values[INDEX_MAX_KEYS];
         bool        existing_isnull[INDEX_MAX_KEYS];
         char       *error_new;
         char       *error_existing;
 
         /*
          * Ignore the entry for the tuple we're trying to check.
          */
         if (ItemPointerIsValid(tupleid) &&
             ItemPointerEquals(tupleid, &existing_slot->tts_tid))
         {
             if (found_self)     /* should not happen */
                 elog(ERROR, "found self tuple multiple times in index \"%s\"",
                      RelationGetRelationName(index));
             found_self = true;
             continue;
         }
 
         /*
          * Extract the index column values and isnull flags from the existing
          * tuple.
          */
         FormIndexDatum(indexInfo, existing_slot, estate,
                        existing_values, existing_isnull);
 
         /* If lossy indexscan, must recheck the condition */
         if (index_scan->xs_recheck)
         {
             if (!index_recheck_constraint(index,
                                           constr_procs,
                                           existing_values,
                                           existing_isnull,
                                           values))
                 continue;       /* tuple doesn't actually match, so no
                                  * conflict */
         }
 
         /*
          * At this point we have either a conflict or a potential conflict.
          *
          * If an in-progress transaction is affecting the visibility of this
          * tuple, we need to wait for it to complete and then recheck (unless
          * the caller requested not to).  For simplicity we do rechecking by
          * just restarting the whole scan --- this case probably doesn't
          * happen often enough to be worth trying harder, and anyway we don't
          * want to hold any index internal locks while waiting.
          */
         xwait = TransactionIdIsValid(DirtySnapshot.xmin) ?
             DirtySnapshot.xmin : DirtySnapshot.xmax;
 
         if (TransactionIdIsValid(xwait) &&
             (waitMode == CEOUC_WAIT ||
              (waitMode == CEOUC_LIVELOCK_PREVENTING_WAIT &&
               DirtySnapshot.speculativeToken &&
               TransactionIdPrecedes(GetCurrentTransactionId(), xwait))))
         {
             reason_wait = indexInfo->ii_ExclusionOps ?
                 XLTW_RecheckExclusionConstr : XLTW_InsertIndex;
             index_endscan(index_scan);
             if (DirtySnapshot.speculativeToken)
                 SpeculativeInsertionWait(DirtySnapshot.xmin,
                                          DirtySnapshot.speculativeToken);
             else
                 XactLockTableWait(xwait, heap,
                                   &existing_slot->tts_tid, reason_wait);
             goto retry;
         }
 
         /*
          * We have a definite conflict (or a potential one, but the caller
          * didn't want to wait).  Return it to caller, or report it.
          */
         if (violationOK)
         {
             conflict = true;
             if (conflictTid)
                 *conflictTid = existing_slot->tts_tid;
             break;
         }
 
         error_new = BuildIndexValueDescription(index, values, isnull);
         error_existing = BuildIndexValueDescription(index, existing_values,
                                                     existing_isnull);
         if (newIndex)
             ereport(ERROR,
                     (errcode(ERRCODE_EXCLUSION_VIOLATION),
                      errmsg("could not create exclusion constraint \"%s\"",
                             RelationGetRelationName(index)),
                      error_new && error_existing ?
                      errdetail("Key %s conflicts with key %s.",
                                error_new, error_existing) :
                      errdetail("Key conflicts exist."),
                      errtableconstraint(heap,
                                         RelationGetRelationName(index))));
         else
             ereport(ERROR,
                     (errcode(ERRCODE_EXCLUSION_VIOLATION),
                      errmsg("conflicting key value violates exclusion constraint \"%s\"",
                             RelationGetRelationName(index)),
                      error_new && error_existing ?
                      errdetail("Key %s conflicts with existing key %s.",
                                error_new, error_existing) :
                      errdetail("Key conflicts with existing key."),
                      errtableconstraint(heap,
                                         RelationGetRelationName(index))));
     }
 
     index_endscan(index_scan);
 
     /*
      * Ordinarily, at this point the search should have found the originally
      * inserted tuple (if any), unless we exited the loop early because of
      * conflict.  However, it is possible to define exclusion constraints for
      * which that wouldn't be true --- for instance, if the operator is <>. So
      * we no longer complain if found_self is still false.
      */
 
     econtext->ecxt_scantuple = save_scantuple;
 
     ExecDropSingleTupleTableSlot(existing_slot);
 
     return !conflict;
 }

◆ ExecCheckIndexConstraints()

bool ExecCheckIndexConstraints	(	TupleTableSlot *	slot,
		EState *	estate,
		ItemPointer	conflictTid,
		List *	arbiterIndexes
	)

Definition at line 482 of file execIndexing.c.

References CEOUC_WAIT, check_exclusion_or_unique_constraint(), ExprContext::ecxt_scantuple, elog, ereport, errcode(), errmsg(), ERROR, errtableconstraint(), EState::es_result_relation_info, ExecPrepareQual(), ExecQual(), FormIndexDatum(), GetPerTupleExprContext, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Predicate, IndexInfo::ii_PredicateState, IndexInfo::ii_ReadyForInserts, IndexInfo::ii_Unique, INDEX_MAX_KEYS, ItemPointerSetInvalid, list_member_oid(), NIL, RelationData::rd_index, RelationGetRelationName, ResultRelInfo::ri_IndexRelationDescs, ResultRelInfo::ri_IndexRelationInfo, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_RelationDesc, and values.

Referenced by exec_rt_fetch(), and ExecInsert().

 {
     ResultRelInfo *resultRelInfo;
     int         i;
     int         numIndices;
     RelationPtr relationDescs;
     Relation    heapRelation;
     IndexInfo **indexInfoArray;
     ExprContext *econtext;
     Datum       values[INDEX_MAX_KEYS];
     bool        isnull[INDEX_MAX_KEYS];
     ItemPointerData invalidItemPtr;
     bool        checkedIndex = false;
 
     ItemPointerSetInvalid(conflictTid);
     ItemPointerSetInvalid(&invalidItemPtr);
 
     /*
      * Get information from the result relation info structure.
      */
     resultRelInfo = estate->es_result_relation_info;
     numIndices = resultRelInfo->ri_NumIndices;
     relationDescs = resultRelInfo->ri_IndexRelationDescs;
     indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
     heapRelation = resultRelInfo->ri_RelationDesc;
 
     /*
      * We will use the EState's per-tuple context for evaluating predicates
      * and index expressions (creating it if it's not already there).
      */
     econtext = GetPerTupleExprContext(estate);
 
     /* Arrange for econtext's scan tuple to be the tuple under test */
     econtext->ecxt_scantuple = slot;
 
     /*
      * For each index, form index tuple and check if it satisfies the
      * constraint.
      */
     for (i = 0; i < numIndices; i++)
     {
         Relation    indexRelation = relationDescs[i];
         IndexInfo  *indexInfo;
         bool        satisfiesConstraint;
 
         if (indexRelation == NULL)
             continue;
 
         indexInfo = indexInfoArray[i];
 
         if (!indexInfo->ii_Unique && !indexInfo->ii_ExclusionOps)
             continue;
 
         /* If the index is marked as read-only, ignore it */
         if (!indexInfo->ii_ReadyForInserts)
             continue;
 
         /* When specific arbiter indexes requested, only examine them */
         if (arbiterIndexes != NIL &&
             !list_member_oid(arbiterIndexes,
                              indexRelation->rd_index->indexrelid))
             continue;
 
         if (!indexRelation->rd_index->indimmediate)
             ereport(ERROR,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("ON CONFLICT does not support deferrable unique constraints/exclusion constraints as arbiters"),
                      errtableconstraint(heapRelation,
                                         RelationGetRelationName(indexRelation))));
 
         checkedIndex = true;
 
         /* Check for partial index */
         if (indexInfo->ii_Predicate != NIL)
         {
             ExprState  *predicate;
 
             /*
              * If predicate state not set up yet, create it (in the estate's
              * per-query context)
              */
             predicate = indexInfo->ii_PredicateState;
             if (predicate == NULL)
             {
                 predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
                 indexInfo->ii_PredicateState = predicate;
             }
 
             /* Skip this index-update if the predicate isn't satisfied */
             if (!ExecQual(predicate, econtext))
                 continue;
         }
 
         /*
          * FormIndexDatum fills in its values and isnull parameters with the
          * appropriate values for the column(s) of the index.
          */
         FormIndexDatum(indexInfo,
                        slot,
                        estate,
                        values,
                        isnull);
 
         satisfiesConstraint =
             check_exclusion_or_unique_constraint(heapRelation, indexRelation,
                                                  indexInfo, &invalidItemPtr,
                                                  values, isnull, estate, false,
                                                  CEOUC_WAIT, true,
                                                  conflictTid);
         if (!satisfiesConstraint)
             return false;
     }
 
     if (arbiterIndexes != NIL && !checkedIndex)
         elog(ERROR, "unexpected failure to find arbiter index");
 
     return true;
 }

◆ ExecCloseIndices()

void ExecCloseIndices ( ResultRelInfo * resultRelInfo )

Definition at line 226 of file execIndexing.c.

References i, index_close(), ResultRelInfo::ri_IndexRelationDescs, ResultRelInfo::ri_NumIndices, and RowExclusiveLock.

Referenced by apply_handle_delete_internal(), apply_handle_insert_internal(), apply_handle_tuple_routing(), apply_handle_update_internal(), CatalogCloseIndexes(), CopyFrom(), exec_rt_fetch(), ExecCleanupTupleRouting(), and ExecEndPlan().

 {
     int         i;
     int         numIndices;
     RelationPtr indexDescs;
 
     numIndices = resultRelInfo->ri_NumIndices;
     indexDescs = resultRelInfo->ri_IndexRelationDescs;
 
     for (i = 0; i < numIndices; i++)
     {
         if (indexDescs[i] == NULL)
             continue;           /* shouldn't happen? */
 
         /* Drop lock acquired by ExecOpenIndices */
         index_close(indexDescs[i], RowExclusiveLock);
     }
 
     /*
      * XXX should free indexInfo array here too?  Currently we assume that
      * such stuff will be cleaned up automatically in FreeExecutorState.
      */
 }

◆ ExecInsertIndexTuples()

List* ExecInsertIndexTuples	(	TupleTableSlot *	slot,
		EState *	estate,
		bool	noDupErr,
		bool *	specConflict,
		List *	arbiterIndexes
	)

Definition at line 273 of file execIndexing.c.

References Assert, CEOUC_LIVELOCK_PREVENTING_WAIT, CEOUC_NOWAIT, CEOUC_WAIT, check_exclusion_or_unique_constraint(), ExprContext::ecxt_scantuple, EState::es_result_relation_info, ExecPrepareQual(), ExecQual(), FormIndexDatum(), GetPerTupleExprContext, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Predicate, IndexInfo::ii_PredicateState, IndexInfo::ii_ReadyForInserts, index_insert(), INDEX_MAX_KEYS, ItemPointerIsValid, lappend_oid(), list_member_oid(), NIL, RelationData::rd_index, RelationGetRelid, ResultRelInfo::ri_IndexRelationDescs, ResultRelInfo::ri_IndexRelationInfo, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_RelationDesc, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tid, UNIQUE_CHECK_NO, UNIQUE_CHECK_PARTIAL, UNIQUE_CHECK_YES, and values.

Referenced by CopyFrom(), CopyMultiInsertBufferFlush(), exec_rt_fetch(), ExecInsert(), ExecSimpleRelationInsert(), ExecSimpleRelationUpdate(), and ExecUpdate().

 {
     ItemPointer tupleid = &slot->tts_tid;
     List       *result = NIL;
     ResultRelInfo *resultRelInfo;
     int         i;
     int         numIndices;
     RelationPtr relationDescs;
     Relation    heapRelation;
     IndexInfo **indexInfoArray;
     ExprContext *econtext;
     Datum       values[INDEX_MAX_KEYS];
     bool        isnull[INDEX_MAX_KEYS];
 
     Assert(ItemPointerIsValid(tupleid));
 
     /*
      * Get information from the result relation info structure.
      */
     resultRelInfo = estate->es_result_relation_info;
     numIndices = resultRelInfo->ri_NumIndices;
     relationDescs = resultRelInfo->ri_IndexRelationDescs;
     indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
     heapRelation = resultRelInfo->ri_RelationDesc;
 
     /* Sanity check: slot must belong to the same rel as the resultRelInfo. */
     Assert(slot->tts_tableOid == RelationGetRelid(heapRelation));
 
     /*
      * We will use the EState's per-tuple context for evaluating predicates
      * and index expressions (creating it if it's not already there).
      */
     econtext = GetPerTupleExprContext(estate);
 
     /* Arrange for econtext's scan tuple to be the tuple under test */
     econtext->ecxt_scantuple = slot;
 
     /*
      * for each index, form and insert the index tuple
      */
     for (i = 0; i < numIndices; i++)
     {
         Relation    indexRelation = relationDescs[i];
         IndexInfo  *indexInfo;
         bool        applyNoDupErr;
         IndexUniqueCheck checkUnique;
         bool        satisfiesConstraint;
 
         if (indexRelation == NULL)
             continue;
 
         indexInfo = indexInfoArray[i];
 
         /* If the index is marked as read-only, ignore it */
         if (!indexInfo->ii_ReadyForInserts)
             continue;
 
         /* Check for partial index */
         if (indexInfo->ii_Predicate != NIL)
         {
             ExprState  *predicate;
 
             /*
              * If predicate state not set up yet, create it (in the estate's
              * per-query context)
              */
             predicate = indexInfo->ii_PredicateState;
             if (predicate == NULL)
             {
                 predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
                 indexInfo->ii_PredicateState = predicate;
             }
 
             /* Skip this index-update if the predicate isn't satisfied */
             if (!ExecQual(predicate, econtext))
                 continue;
         }
 
         /*
          * FormIndexDatum fills in its values and isnull parameters with the
          * appropriate values for the column(s) of the index.
          */
         FormIndexDatum(indexInfo,
                        slot,
                        estate,
                        values,
                        isnull);
 
         /* Check whether to apply noDupErr to this index */
         applyNoDupErr = noDupErr &&
             (arbiterIndexes == NIL ||
              list_member_oid(arbiterIndexes,
                              indexRelation->rd_index->indexrelid));
 
         /*
          * The index AM does the actual insertion, plus uniqueness checking.
          *
          * For an immediate-mode unique index, we just tell the index AM to
          * throw error if not unique.
          *
          * For a deferrable unique index, we tell the index AM to just detect
          * possible non-uniqueness, and we add the index OID to the result
          * list if further checking is needed.
          *
          * For a speculative insertion (used by INSERT ... ON CONFLICT), do
          * the same as for a deferrable unique index.
          */
         if (!indexRelation->rd_index->indisunique)
             checkUnique = UNIQUE_CHECK_NO;
         else if (applyNoDupErr)
             checkUnique = UNIQUE_CHECK_PARTIAL;
         else if (indexRelation->rd_index->indimmediate)
             checkUnique = UNIQUE_CHECK_YES;
         else
             checkUnique = UNIQUE_CHECK_PARTIAL;
 
         satisfiesConstraint =
             index_insert(indexRelation, /* index relation */
                          values,    /* array of index Datums */
                          isnull,    /* null flags */
                          tupleid,   /* tid of heap tuple */
                          heapRelation,  /* heap relation */
                          checkUnique,   /* type of uniqueness check to do */
                          indexInfo);    /* index AM may need this */
 
         /*
          * If the index has an associated exclusion constraint, check that.
          * This is simpler than the process for uniqueness checks since we
          * always insert first and then check.  If the constraint is deferred,
          * we check now anyway, but don't throw error on violation or wait for
          * a conclusive outcome from a concurrent insertion; instead we'll
          * queue a recheck event.  Similarly, noDupErr callers (speculative
          * inserters) will recheck later, and wait for a conclusive outcome
          * then.
          *
          * An index for an exclusion constraint can't also be UNIQUE (not an
          * essential property, we just don't allow it in the grammar), so no
          * need to preserve the prior state of satisfiesConstraint.
          */
         if (indexInfo->ii_ExclusionOps != NULL)
         {
             bool        violationOK;
             CEOUC_WAIT_MODE waitMode;
 
             if (applyNoDupErr)
             {
                 violationOK = true;
                 waitMode = CEOUC_LIVELOCK_PREVENTING_WAIT;
             }
             else if (!indexRelation->rd_index->indimmediate)
             {
                 violationOK = true;
                 waitMode = CEOUC_NOWAIT;
             }
             else
             {
                 violationOK = false;
                 waitMode = CEOUC_WAIT;
             }
 
             satisfiesConstraint =
                 check_exclusion_or_unique_constraint(heapRelation,
                                                      indexRelation, indexInfo,
                                                      tupleid, values, isnull,
                                                      estate, false,
                                                      waitMode, violationOK, NULL);
         }
 
         if ((checkUnique == UNIQUE_CHECK_PARTIAL ||
              indexInfo->ii_ExclusionOps != NULL) &&
             !satisfiesConstraint)
         {
             /*
              * The tuple potentially violates the uniqueness or exclusion
              * constraint, so make a note of the index so that we can re-check
              * it later.  Speculative inserters are told if there was a
              * speculative conflict, since that always requires a restart.
              */
             result = lappend_oid(result, RelationGetRelid(indexRelation));
             if (indexRelation->rd_index->indimmediate && specConflict)
                 *specConflict = true;
         }
     }
 
     return result;
 }

◆ ExecOpenIndices()

void ExecOpenIndices	(	ResultRelInfo *	resultRelInfo,
		bool	speculative
	)

Definition at line 151 of file execIndexing.c.

References BuildIndexInfo(), BuildSpeculativeIndexInfo(), i, IndexInfo::ii_Unique, index_open(), lfirst_oid, list_free(), list_length(), palloc(), RelationGetForm, RelationGetIndexList(), ResultRelInfo::ri_IndexRelationDescs, ResultRelInfo::ri_IndexRelationInfo, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_RelationDesc, and RowExclusiveLock.

Referenced by apply_handle_delete_internal(), apply_handle_insert_internal(), apply_handle_tuple_routing(), apply_handle_update_internal(), CatalogOpenIndexes(), CopyFrom(), exec_rt_fetch(), ExecInitModifyTable(), and ExecInitPartitionInfo().

 {
     Relation    resultRelation = resultRelInfo->ri_RelationDesc;
     List       *indexoidlist;
     ListCell   *l;
     int         len,
                 i;
     RelationPtr relationDescs;
     IndexInfo **indexInfoArray;
 
     resultRelInfo->ri_NumIndices = 0;
 
     /* fast path if no indexes */
     if (!RelationGetForm(resultRelation)->relhasindex)
         return;
 
     /*
      * Get cached list of index OIDs
      */
     indexoidlist = RelationGetIndexList(resultRelation);
     len = list_length(indexoidlist);
     if (len == 0)
         return;
 
     /*
      * allocate space for result arrays
      */
     relationDescs = (RelationPtr) palloc(len * sizeof(Relation));
     indexInfoArray = (IndexInfo **) palloc(len * sizeof(IndexInfo *));
 
     resultRelInfo->ri_NumIndices = len;
     resultRelInfo->ri_IndexRelationDescs = relationDescs;
     resultRelInfo->ri_IndexRelationInfo = indexInfoArray;
 
     /*
      * For each index, open the index relation and save pg_index info. We
      * acquire RowExclusiveLock, signifying we will update the index.
      *
      * Note: we do this even if the index is not indisready; it's not worth
      * the trouble to optimize for the case where it isn't.
      */
     i = 0;
     foreach(l, indexoidlist)
     {
         Oid         indexOid = lfirst_oid(l);
         Relation    indexDesc;
         IndexInfo  *ii;
 
         indexDesc = index_open(indexOid, RowExclusiveLock);
 
         /* extract index key information from the index's pg_index info */
         ii = BuildIndexInfo(indexDesc);
 
         /*
          * If the indexes are to be used for speculative insertion, add extra
          * information required by unique index entries.
          */
         if (speculative && ii->ii_Unique)
             BuildSpeculativeIndexInfo(indexDesc, ii);
 
         relationDescs[i] = indexDesc;
         indexInfoArray[i] = ii;
         i++;
     }
 
     list_free(indexoidlist);
 }

◆ index_recheck_constraint()

static bool index_recheck_constraint	(	Relation	index,
		Oid *	constr_procs,
		Datum *	existing_values,
		bool *	existing_isnull,
		Datum *	new_values
	)

static

Definition at line 883 of file execIndexing.c.

References DatumGetBool, i, IndexRelationGetNumberOfKeyAttributes, OidFunctionCall2Coll(), and RelationData::rd_indcollation.

Referenced by check_exclusion_or_unique_constraint().

 {
     int         indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
     int         i;
 
     for (i = 0; i < indnkeyatts; i++)
     {
         /* Assume the exclusion operators are strict */
         if (existing_isnull[i])
             return false;
 
         if (!DatumGetBool(OidFunctionCall2Coll(constr_procs[i],
                                                index->rd_indcollation[i],
                                                existing_values[i],
                                                new_values[i])))
             return false;
     }
 
     return true;
 }

Enumerations

Functions