execIndexing.c File Reference

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

Go to the source code of this file.

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, const Datum *values, const bool *isnull, EState *estate, bool newIndex, CEOUC_WAIT_MODE waitMode, bool violationOK, ItemPointer conflictTid)
static bool	index_recheck_constraint (Relation index, const Oid *constr_procs, const Datum *existing_values, const bool *existing_isnull, const Datum *new_values)
static bool	index_unchanged_by_update (ResultRelInfo *resultRelInfo, EState *estate, IndexInfo *indexInfo, Relation indexRelation)
static bool	index_expression_changed_walker (Node *node, Bitmapset *allUpdatedCols)
void	ExecOpenIndices (ResultRelInfo *resultRelInfo, bool speculative)
void	ExecCloseIndices (ResultRelInfo *resultRelInfo)
List *	ExecInsertIndexTuples (ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, bool update, bool noDupErr, bool *specConflict, List *arbiterIndexes, bool onlySummarizing)
bool	ExecCheckIndexConstraints (ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, ItemPointer conflictTid, ItemPointer tupleid, List *arbiterIndexes)
void	check_exclusion_constraint (Relation heap, Relation index, IndexInfo *indexInfo, ItemPointer tupleid, const Datum *values, const 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,
		const Datum *	values,
		const bool *	isnull,
		EState *	estate,
		bool	newIndex
	)

Definition at line 920 of file execIndexing.c.

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

References CEOUC_WAIT, check_exclusion_or_unique_constraint(), and values.

Referenced by IndexCheckExclusion().

check_exclusion_or_unique_constraint()

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

static

Definition at line 694 of file execIndexing.c.

{
    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, and the index uses the default
     * nulls-are-distinct mode, the constraint check is assumed to pass (i.e.,
     * we assume the operators are strict).  Otherwise, we interpret the
     * constraint as specifying IS NULL for each column whose input value is
     * NULL.
     */
    if (!indexInfo->ii_NullsNotDistinct)
    {
        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],
                               isnull[i] ? SK_ISNULL | SK_SEARCHNULL : 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;
}

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_NullsNotDistinct, 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(), RelationGetRelationName, ScanKeyEntryInitialize(), SK_ISNULL, SK_SEARCHNULL, SpeculativeInsertionWait(), SnapshotData::speculativeToken, table_slot_create(), TransactionIdIsValid, TransactionIdPrecedes(), TupleTableSlot::tts_tid, values, XactLockTableWait(), XLTW_InsertIndex, XLTW_RecheckExclusionConstr, SnapshotData::xmax, SnapshotData::xmin, and IndexScanDescData::xs_recheck.

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

ExecCheckIndexConstraints()

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

Definition at line 532 of file execIndexing.c.

{
    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.
     */
    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, tupleid,
                                                 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;
}

References CEOUC_WAIT, check_exclusion_or_unique_constraint(), ExprContext::ecxt_scantuple, elog, ereport, errcode(), errmsg(), ERROR, errtableconstraint(), 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 ExecInsert(), and FindConflictTuple().

ExecCloseIndices()

void ExecCloseIndices

(

ResultRelInfo *

resultRelInfo

)

Definition at line 232 of file execIndexing.c.

{
    int         i;
    int         numIndices;
    RelationPtr indexDescs;
    IndexInfo **indexInfos;
 
    numIndices = resultRelInfo->ri_NumIndices;
    indexDescs = resultRelInfo->ri_IndexRelationDescs;
    indexInfos = resultRelInfo->ri_IndexRelationInfo;
 
    for (i = 0; i < numIndices; i++)
    {
        if (indexDescs[i] == NULL)
            continue;           /* shouldn't happen? */
 
        /* Give the index a chance to do some post-insert cleanup */
        index_insert_cleanup(indexDescs[i], indexInfos[i]);
 
        /* 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.
     */
}

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

Referenced by apply_handle_delete_internal(), apply_handle_insert_internal(), apply_handle_tuple_routing(), apply_handle_update_internal(), CatalogCloseIndexes(), ExecCleanupTupleRouting(), and ExecCloseResultRelations().

ExecInsertIndexTuples()

List* ExecInsertIndexTuples	(	ResultRelInfo *	resultRelInfo,
		TupleTableSlot *	slot,
		EState *	estate,
		bool	update,
		bool	noDupErr,
		bool *	specConflict,
		List *	arbiterIndexes,
		bool	onlySummarizing
	)

Definition at line 299 of file execIndexing.c.

{
    ItemPointer tupleid = &slot->tts_tid;
    List       *result = NIL;
    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.
     */
    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        indexUnchanged;
        bool        satisfiesConstraint;
 
        if (indexRelation == NULL)
            continue;
 
        indexInfo = indexInfoArray[i];
 
        /* If the index is marked as read-only, ignore it */
        if (!indexInfo->ii_ReadyForInserts)
            continue;
 
        /*
         * Skip processing of non-summarizing indexes if we only update
         * summarizing indexes
         */
        if (onlySummarizing && !indexInfo->ii_Summarizing)
            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;
 
        /*
         * There's definitely going to be an index_insert() call for this
         * index.  If we're being called as part of an UPDATE statement,
         * consider if the 'indexUnchanged' = true hint should be passed.
         */
        indexUnchanged = update && index_unchanged_by_update(resultRelInfo,
                                                             estate,
                                                             indexInfo,
                                                             indexRelation);
 
        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 */
                         indexUnchanged,    /* UPDATE without logical change? */
                         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;
}

References Assert, CEOUC_LIVELOCK_PREVENTING_WAIT, CEOUC_NOWAIT, CEOUC_WAIT, check_exclusion_or_unique_constraint(), ExprContext::ecxt_scantuple, ExecPrepareQual(), ExecQual(), FormIndexDatum(), GetPerTupleExprContext, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Predicate, IndexInfo::ii_PredicateState, IndexInfo::ii_ReadyForInserts, IndexInfo::ii_Summarizing, index_insert(), INDEX_MAX_KEYS, index_unchanged_by_update(), 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(), ExecInsert(), ExecSimpleRelationInsert(), ExecSimpleRelationUpdate(), and ExecUpdateEpilogue().

ExecOpenIndices()

void ExecOpenIndices	(	ResultRelInfo *	resultRelInfo,
		bool	speculative
	)

Definition at line 156 of file execIndexing.c.

{
    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 or conflict
         * detection in logical replication, 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);
}

References BuildIndexInfo(), BuildSpeculativeIndexInfo(), i, IndexInfo::ii_Unique, index_open(), len, 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(), ExecInitPartitionInfo(), ExecInsert(), and ExecUpdatePrologue().

index_expression_changed_walker()

static bool index_expression_changed_walker ( Node *  node, Bitmapset *  allUpdatedCols  )

static

Definition at line 1082 of file execIndexing.c.

{
    if (node == NULL)
        return false;
 
    if (IsA(node, Var))
    {
        Var        *var = (Var *) node;
 
        if (bms_is_member(var->varattno - FirstLowInvalidHeapAttributeNumber,
                          allUpdatedCols))
        {
            /* Var was updated -- indicates that we should not hint */
            return true;
        }
 
        /* Still haven't found a reason to not pass the hint */
        return false;
    }
 
    return expression_tree_walker(node, index_expression_changed_walker,
                                  (void *) allUpdatedCols);
}

References bms_is_member(), expression_tree_walker, FirstLowInvalidHeapAttributeNumber, IsA, and Var::varattno.

Referenced by index_unchanged_by_update().

index_recheck_constraint()

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

static

Definition at line 937 of file execIndexing.c.

{
    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;
}

References DatumGetBool(), i, IndexRelationGetNumberOfKeyAttributes, and OidFunctionCall2Coll().

Referenced by check_exclusion_or_unique_constraint().

index_unchanged_by_update()

static bool index_unchanged_by_update ( ResultRelInfo *  resultRelInfo, EState *  estate, IndexInfo *  indexInfo, Relation  indexRelation  )

static

Definition at line 968 of file execIndexing.c.

{
    Bitmapset  *updatedCols;
    Bitmapset  *extraUpdatedCols;
    Bitmapset  *allUpdatedCols;
    bool        hasexpression = false;
    List       *idxExprs;
 
    /*
     * Check cache first
     */
    if (indexInfo->ii_CheckedUnchanged)
        return indexInfo->ii_IndexUnchanged;
    indexInfo->ii_CheckedUnchanged = true;
 
    /*
     * Check for indexed attribute overlap with updated columns.
     *
     * Only do this for key columns.  A change to a non-key column within an
     * INCLUDE index should not be counted here.  Non-key column values are
     * opaque payload state to the index AM, a little like an extra table TID.
     *
     * Note that row-level BEFORE triggers won't affect our behavior, since
     * they don't affect the updatedCols bitmaps generally.  It doesn't seem
     * worth the trouble of checking which attributes were changed directly.
     */
    updatedCols = ExecGetUpdatedCols(resultRelInfo, estate);
    extraUpdatedCols = ExecGetExtraUpdatedCols(resultRelInfo, estate);
    for (int attr = 0; attr < indexInfo->ii_NumIndexKeyAttrs; attr++)
    {
        int         keycol = indexInfo->ii_IndexAttrNumbers[attr];
 
        if (keycol <= 0)
        {
            /*
             * Skip expressions for now, but remember to deal with them later
             * on
             */
            hasexpression = true;
            continue;
        }
 
        if (bms_is_member(keycol - FirstLowInvalidHeapAttributeNumber,
                          updatedCols) ||
            bms_is_member(keycol - FirstLowInvalidHeapAttributeNumber,
                          extraUpdatedCols))
        {
            /* Changed key column -- don't hint for this index */
            indexInfo->ii_IndexUnchanged = false;
            return false;
        }
    }
 
    /*
     * When we get this far and index has no expressions, return true so that
     * index_insert() call will go on to pass 'indexUnchanged' = true hint.
     *
     * The _absence_ of an indexed key attribute that overlaps with updated
     * attributes (in addition to the total absence of indexed expressions)
     * shows that the index as a whole is logically unchanged by UPDATE.
     */
    if (!hasexpression)
    {
        indexInfo->ii_IndexUnchanged = true;
        return true;
    }
 
    /*
     * Need to pass only one bms to expression_tree_walker helper function.
     * Avoid allocating memory in common case where there are no extra cols.
     */
    if (!extraUpdatedCols)
        allUpdatedCols = updatedCols;
    else
        allUpdatedCols = bms_union(updatedCols, extraUpdatedCols);
 
    /*
     * We have to work slightly harder in the event of indexed expressions,
     * but the principle is the same as before: try to find columns (Vars,
     * actually) that overlap with known-updated columns.
     *
     * If we find any matching Vars, don't pass hint for index.  Otherwise
     * pass hint.
     */
    idxExprs = RelationGetIndexExpressions(indexRelation);
    hasexpression = index_expression_changed_walker((Node *) idxExprs,
                                                    allUpdatedCols);
    list_free(idxExprs);
    if (extraUpdatedCols)
        bms_free(allUpdatedCols);
 
    if (hasexpression)
    {
        indexInfo->ii_IndexUnchanged = false;
        return false;
    }
 
    /*
     * Deliberately don't consider index predicates.  We should even give the
     * hint when result rel's "updated tuple" has no corresponding index
     * tuple, which is possible with a partial index (provided the usual
     * conditions are met).
     */
    indexInfo->ii_IndexUnchanged = true;
    return true;
}

References bms_free(), bms_is_member(), bms_union(), ExecGetExtraUpdatedCols(), ExecGetUpdatedCols(), FirstLowInvalidHeapAttributeNumber, IndexInfo::ii_CheckedUnchanged, IndexInfo::ii_IndexAttrNumbers, IndexInfo::ii_IndexUnchanged, IndexInfo::ii_NumIndexKeyAttrs, index_expression_changed_walker(), list_free(), and RelationGetIndexExpressions().

Referenced by ExecInsertIndexTuples().