mirror of
https://github.com/postgres/postgres.git
synced 2025-04-22 23:02:54 +03:00
Move functions related to index maintenance to separate source file.
There is enough code here to deserve a file of their own, not be buried in the middle of execUtils.c.
This commit is contained in:
Heikki Linnakangas
parent
2c47fe16a7
commit
62420ae7d6
@ -12,8 +12,8 @@ subdir = src/backend/executor
|
|||||||
top_builddir = ../../..
|
top_builddir = ../../..
|
||||||
include $(top_builddir)/src/Makefile.global
|
include $(top_builddir)/src/Makefile.global
|
||||||
|
|
||||||
OBJS = execAmi.o execCurrent.o execGrouping.o execJunk.o execMain.o \
|
OBJS = execAmi.o execCurrent.o execGrouping.o execIndexing.o execJunk.o \
|
||||||
execProcnode.o execQual.o execScan.o execTuples.o \
|
execMain.o execProcnode.o execQual.o execScan.o execTuples.o \
|
||||||
execUtils.o functions.o instrument.o nodeAppend.o nodeAgg.o \
|
execUtils.o functions.o instrument.o nodeAppend.o nodeAgg.o \
|
||||||
nodeBitmapAnd.o nodeBitmapOr.o \
|
nodeBitmapAnd.o nodeBitmapOr.o \
|
||||||
nodeBitmapHeapscan.o nodeBitmapIndexscan.o nodeCustom.o nodeHash.o \
|
nodeBitmapHeapscan.o nodeBitmapIndexscan.o nodeCustom.o nodeHash.o \
|
||||||
|
|||||||
541
src/backend/executor/execIndexing.c
Normal file
541
src/backend/executor/execIndexing.c
Normal file
@ -0,0 +1,541 @@
|
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
*
|
||||||
|
* execIndexing.c
|
||||||
|
* executor support for maintaining indexes
|
||||||
|
*
|
||||||
|
* Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
|
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California
|
||||||
|
*
|
||||||
|
*
|
||||||
|
* IDENTIFICATION
|
||||||
|
* src/backend/executor/execIndexing.c
|
||||||
|
*
|
||||||
|
*-------------------------------------------------------------------------
|
||||||
|
*/
|
||||||
|
#include "postgres.h"
|
||||||
|
|
||||||
|
#include "access/relscan.h"
|
||||||
|
#include "catalog/index.h"
|
||||||
|
#include "executor/executor.h"
|
||||||
|
#include "nodes/nodeFuncs.h"
|
||||||
|
#include "storage/lmgr.h"
|
||||||
|
#include "utils/tqual.h"
|
||||||
|
|
||||||
|
static bool index_recheck_constraint(Relation index, Oid *constr_procs,
|
||||||
|
Datum *existing_values, bool *existing_isnull,
|
||||||
|
Datum *new_values);
|
||||||
|
|
||||||
|
/* ----------------------------------------------------------------
|
||||||
|
* ExecOpenIndices
|
||||||
|
*
|
||||||
|
* Find the indices associated with a result relation, open them,
|
||||||
|
* and save information about them in the result ResultRelInfo.
|
||||||
|
*
|
||||||
|
* At entry, caller has already opened and locked
|
||||||
|
* resultRelInfo->ri_RelationDesc.
|
||||||
|
* ----------------------------------------------------------------
|
||||||
|
*/
|
||||||
|
void
|
||||||
|
ExecOpenIndices(ResultRelInfo *resultRelInfo)
|
||||||
|
{
|
||||||
|
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 IndexIsReady; 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);
|
||||||
|
|
||||||
|
relationDescs[i] = indexDesc;
|
||||||
|
indexInfoArray[i] = ii;
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
|
||||||
|
list_free(indexoidlist);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ----------------------------------------------------------------
|
||||||
|
* ExecCloseIndices
|
||||||
|
*
|
||||||
|
* Close the index relations stored in resultRelInfo
|
||||||
|
* ----------------------------------------------------------------
|
||||||
|
*/
|
||||||
|
void
|
||||||
|
ExecCloseIndices(ResultRelInfo *resultRelInfo)
|
||||||
|
{
|
||||||
|
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
|
||||||
|
*
|
||||||
|
* This routine takes care of inserting index tuples
|
||||||
|
* into all the relations indexing the result relation
|
||||||
|
* when a heap tuple is inserted into the result relation.
|
||||||
|
* Much of this code should be moved into the genam
|
||||||
|
* stuff as it only exists here because the genam stuff
|
||||||
|
* doesn't provide the functionality needed by the
|
||||||
|
* executor.. -cim 9/27/89
|
||||||
|
*
|
||||||
|
* This returns a list of index OIDs for any unique or exclusion
|
||||||
|
* constraints that are deferred and that had
|
||||||
|
* potential (unconfirmed) conflicts.
|
||||||
|
*
|
||||||
|
* CAUTION: this must not be called for a HOT update.
|
||||||
|
* We can't defend against that here for lack of info.
|
||||||
|
* Should we change the API to make it safer?
|
||||||
|
* ----------------------------------------------------------------
|
||||||
|
*/
|
||||||
|
List *
|
||||||
|
ExecInsertIndexTuples(TupleTableSlot *slot,
|
||||||
|
ItemPointer tupleid,
|
||||||
|
EState *estate)
|
||||||
|
{
|
||||||
|
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];
|
||||||
|
|
||||||
|
/*
|
||||||
|
* 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 and insert the index tuple
|
||||||
|
*/
|
||||||
|
for (i = 0; i < numIndices; i++)
|
||||||
|
{
|
||||||
|
Relation indexRelation = relationDescs[i];
|
||||||
|
IndexInfo *indexInfo;
|
||||||
|
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)
|
||||||
|
{
|
||||||
|
List *predicate;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If predicate state not set up yet, create it (in the estate's
|
||||||
|
* per-query context)
|
||||||
|
*/
|
||||||
|
predicate = indexInfo->ii_PredicateState;
|
||||||
|
if (predicate == NIL)
|
||||||
|
{
|
||||||
|
predicate = (List *)
|
||||||
|
ExecPrepareExpr((Expr *) indexInfo->ii_Predicate,
|
||||||
|
estate);
|
||||||
|
indexInfo->ii_PredicateState = predicate;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Skip this index-update if the predicate isn't satisfied */
|
||||||
|
if (!ExecQual(predicate, econtext, false))
|
||||||
|
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);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* 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.
|
||||||
|
*/
|
||||||
|
if (!indexRelation->rd_index->indisunique)
|
||||||
|
checkUnique = UNIQUE_CHECK_NO;
|
||||||
|
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 */
|
||||||
|
|
||||||
|
/*
|
||||||
|
* 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; instead
|
||||||
|
* we'll queue a recheck event.
|
||||||
|
*
|
||||||
|
* 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 errorOK = !indexRelation->rd_index->indimmediate;
|
||||||
|
|
||||||
|
satisfiesConstraint =
|
||||||
|
check_exclusion_constraint(heapRelation,
|
||||||
|
indexRelation, indexInfo,
|
||||||
|
tupleid, values, isnull,
|
||||||
|
estate, false, errorOK);
|
||||||
|
}
|
||||||
|
|
||||||
|
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.
|
||||||
|
*/
|
||||||
|
result = lappend_oid(result, RelationGetRelid(indexRelation));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Check for violation of an exclusion constraint
|
||||||
|
*
|
||||||
|
* heap: the table containing the new tuple
|
||||||
|
* index: the index supporting the exclusion constraint
|
||||||
|
* indexInfo: info about the index, including the exclusion properties
|
||||||
|
* tupleid: heap TID of the new tuple we have just inserted
|
||||||
|
* values, isnull: the *index* column values computed for the new tuple
|
||||||
|
* estate: an EState we can do evaluation in
|
||||||
|
* newIndex: if true, we are trying to build a new index (this affects
|
||||||
|
* only the wording of error messages)
|
||||||
|
* errorOK: if true, don't throw error for violation
|
||||||
|
*
|
||||||
|
* Returns true if OK, false if actual or potential violation
|
||||||
|
*
|
||||||
|
* When errorOK is true, we report violation without waiting to see if any
|
||||||
|
* concurrent transaction has committed or not; so the violation is only
|
||||||
|
* potential, and the caller must recheck sometime later. This behavior
|
||||||
|
* is convenient for deferred exclusion checks; we need not bother queuing
|
||||||
|
* a deferred event if there is definitely no conflict at insertion time.
|
||||||
|
*
|
||||||
|
* When errorOK is false, we'll throw error on violation, so a false result
|
||||||
|
* is impossible.
|
||||||
|
*/
|
||||||
|
bool
|
||||||
|
check_exclusion_constraint(Relation heap, Relation index, IndexInfo *indexInfo,
|
||||||
|
ItemPointer tupleid, Datum *values, bool *isnull,
|
||||||
|
EState *estate, bool newIndex, bool errorOK)
|
||||||
|
{
|
||||||
|
Oid *constr_procs = indexInfo->ii_ExclusionProcs;
|
||||||
|
uint16 *constr_strats = indexInfo->ii_ExclusionStrats;
|
||||||
|
Oid *index_collations = index->rd_indcollation;
|
||||||
|
int index_natts = index->rd_index->indnatts;
|
||||||
|
IndexScanDesc index_scan;
|
||||||
|
HeapTuple tup;
|
||||||
|
ScanKeyData scankeys[INDEX_MAX_KEYS];
|
||||||
|
SnapshotData DirtySnapshot;
|
||||||
|
int i;
|
||||||
|
bool conflict;
|
||||||
|
bool found_self;
|
||||||
|
ExprContext *econtext;
|
||||||
|
TupleTableSlot *existing_slot;
|
||||||
|
TupleTableSlot *save_scantuple;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* 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 < index_natts; 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 < index_natts; 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 = MakeSingleTupleTableSlot(RelationGetDescr(heap));
|
||||||
|
|
||||||
|
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, index_natts, 0);
|
||||||
|
index_rescan(index_scan, scankeys, index_natts, NULL, 0);
|
||||||
|
|
||||||
|
while ((tup = index_getnext(index_scan,
|
||||||
|
ForwardScanDirection)) != NULL)
|
||||||
|
{
|
||||||
|
TransactionId xwait;
|
||||||
|
ItemPointerData ctid_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 (ItemPointerEquals(tupleid, &tup->t_self))
|
||||||
|
{
|
||||||
|
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.
|
||||||
|
*/
|
||||||
|
ExecStoreTuple(tup, existing_slot, InvalidBuffer, false);
|
||||||
|
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
|
||||||
|
* we're not supposed to raise error, just return the fact of the
|
||||||
|
* potential conflict without waiting to see if it's real.
|
||||||
|
*/
|
||||||
|
if (errorOK)
|
||||||
|
{
|
||||||
|
conflict = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If an in-progress transaction is affecting the visibility of this
|
||||||
|
* tuple, we need to wait for it to complete and then recheck. 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))
|
||||||
|
{
|
||||||
|
ctid_wait = tup->t_data->t_ctid;
|
||||||
|
index_endscan(index_scan);
|
||||||
|
XactLockTableWait(xwait, heap, &ctid_wait,
|
||||||
|
XLTW_RecheckExclusionConstr);
|
||||||
|
goto retry;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* We have a definite conflict. Report it.
|
||||||
|
*/
|
||||||
|
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, 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;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Check existing tuple's index values to see if it really matches the
|
||||||
|
* exclusion condition against the new_values. Returns true if conflict.
|
||||||
|
*/
|
||||||
|
static bool
|
||||||
|
index_recheck_constraint(Relation index, Oid *constr_procs,
|
||||||
|
Datum *existing_values, bool *existing_isnull,
|
||||||
|
Datum *new_values)
|
||||||
|
{
|
||||||
|
int index_natts = index->rd_index->indnatts;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = 0; i < index_natts; 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;
|
||||||
|
}
|
||||||
@ -28,10 +28,6 @@
|
|||||||
* ExecOpenScanRelation Common code for scan node init routines.
|
* ExecOpenScanRelation Common code for scan node init routines.
|
||||||
* ExecCloseScanRelation
|
* ExecCloseScanRelation
|
||||||
*
|
*
|
||||||
* ExecOpenIndices \
|
|
||||||
* ExecCloseIndices | referenced by InitPlan, EndPlan,
|
|
||||||
* ExecInsertIndexTuples / ExecInsert, ExecUpdate
|
|
||||||
*
|
|
||||||
* RegisterExprContextCallback Register function shutdown callback
|
* RegisterExprContextCallback Register function shutdown callback
|
||||||
* UnregisterExprContextCallback Deregister function shutdown callback
|
* UnregisterExprContextCallback Deregister function shutdown callback
|
||||||
*
|
*
|
||||||
@ -44,19 +40,14 @@
|
|||||||
|
|
||||||
#include "access/relscan.h"
|
#include "access/relscan.h"
|
||||||
#include "access/transam.h"
|
#include "access/transam.h"
|
||||||
#include "catalog/index.h"
|
#include "executor/executor.h"
|
||||||
#include "executor/execdebug.h"
|
|
||||||
#include "nodes/nodeFuncs.h"
|
#include "nodes/nodeFuncs.h"
|
||||||
#include "parser/parsetree.h"
|
#include "parser/parsetree.h"
|
||||||
#include "storage/lmgr.h"
|
|
||||||
#include "utils/memutils.h"
|
#include "utils/memutils.h"
|
||||||
#include "utils/tqual.h"
|
#include "utils/rel.h"
|
||||||
|
|
||||||
|
|
||||||
static bool get_last_attnums(Node *node, ProjectionInfo *projInfo);
|
static bool get_last_attnums(Node *node, ProjectionInfo *projInfo);
|
||||||
static bool index_recheck_constraint(Relation index, Oid *constr_procs,
|
|
||||||
Datum *existing_values, bool *existing_isnull,
|
|
||||||
Datum *new_values);
|
|
||||||
static void ShutdownExprContext(ExprContext *econtext, bool isCommit);
|
static void ShutdownExprContext(ExprContext *econtext, bool isCommit);
|
||||||
|
|
||||||
|
|
||||||
@ -870,527 +861,6 @@ ExecCloseScanRelation(Relation scanrel)
|
|||||||
heap_close(scanrel, NoLock);
|
heap_close(scanrel, NoLock);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
/* ----------------------------------------------------------------
|
|
||||||
* ExecInsertIndexTuples support
|
|
||||||
* ----------------------------------------------------------------
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* ----------------------------------------------------------------
|
|
||||||
* ExecOpenIndices
|
|
||||||
*
|
|
||||||
* Find the indices associated with a result relation, open them,
|
|
||||||
* and save information about them in the result ResultRelInfo.
|
|
||||||
*
|
|
||||||
* At entry, caller has already opened and locked
|
|
||||||
* resultRelInfo->ri_RelationDesc.
|
|
||||||
* ----------------------------------------------------------------
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
ExecOpenIndices(ResultRelInfo *resultRelInfo)
|
|
||||||
{
|
|
||||||
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 IndexIsReady; 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);
|
|
||||||
|
|
||||||
relationDescs[i] = indexDesc;
|
|
||||||
indexInfoArray[i] = ii;
|
|
||||||
i++;
|
|
||||||
}
|
|
||||||
|
|
||||||
list_free(indexoidlist);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* ----------------------------------------------------------------
|
|
||||||
* ExecCloseIndices
|
|
||||||
*
|
|
||||||
* Close the index relations stored in resultRelInfo
|
|
||||||
* ----------------------------------------------------------------
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
ExecCloseIndices(ResultRelInfo *resultRelInfo)
|
|
||||||
{
|
|
||||||
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
|
|
||||||
*
|
|
||||||
* This routine takes care of inserting index tuples
|
|
||||||
* into all the relations indexing the result relation
|
|
||||||
* when a heap tuple is inserted into the result relation.
|
|
||||||
* Much of this code should be moved into the genam
|
|
||||||
* stuff as it only exists here because the genam stuff
|
|
||||||
* doesn't provide the functionality needed by the
|
|
||||||
* executor.. -cim 9/27/89
|
|
||||||
*
|
|
||||||
* This returns a list of index OIDs for any unique or exclusion
|
|
||||||
* constraints that are deferred and that had
|
|
||||||
* potential (unconfirmed) conflicts.
|
|
||||||
*
|
|
||||||
* CAUTION: this must not be called for a HOT update.
|
|
||||||
* We can't defend against that here for lack of info.
|
|
||||||
* Should we change the API to make it safer?
|
|
||||||
* ----------------------------------------------------------------
|
|
||||||
*/
|
|
||||||
List *
|
|
||||||
ExecInsertIndexTuples(TupleTableSlot *slot,
|
|
||||||
ItemPointer tupleid,
|
|
||||||
EState *estate)
|
|
||||||
{
|
|
||||||
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];
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 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 and insert the index tuple
|
|
||||||
*/
|
|
||||||
for (i = 0; i < numIndices; i++)
|
|
||||||
{
|
|
||||||
Relation indexRelation = relationDescs[i];
|
|
||||||
IndexInfo *indexInfo;
|
|
||||||
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)
|
|
||||||
{
|
|
||||||
List *predicate;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If predicate state not set up yet, create it (in the estate's
|
|
||||||
* per-query context)
|
|
||||||
*/
|
|
||||||
predicate = indexInfo->ii_PredicateState;
|
|
||||||
if (predicate == NIL)
|
|
||||||
{
|
|
||||||
predicate = (List *)
|
|
||||||
ExecPrepareExpr((Expr *) indexInfo->ii_Predicate,
|
|
||||||
estate);
|
|
||||||
indexInfo->ii_PredicateState = predicate;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Skip this index-update if the predicate isn't satisfied */
|
|
||||||
if (!ExecQual(predicate, econtext, false))
|
|
||||||
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);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*/
|
|
||||||
if (!indexRelation->rd_index->indisunique)
|
|
||||||
checkUnique = UNIQUE_CHECK_NO;
|
|
||||||
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 */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 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; instead
|
|
||||||
* we'll queue a recheck event.
|
|
||||||
*
|
|
||||||
* 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 errorOK = !indexRelation->rd_index->indimmediate;
|
|
||||||
|
|
||||||
satisfiesConstraint =
|
|
||||||
check_exclusion_constraint(heapRelation,
|
|
||||||
indexRelation, indexInfo,
|
|
||||||
tupleid, values, isnull,
|
|
||||||
estate, false, errorOK);
|
|
||||||
}
|
|
||||||
|
|
||||||
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.
|
|
||||||
*/
|
|
||||||
result = lappend_oid(result, RelationGetRelid(indexRelation));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Check for violation of an exclusion constraint
|
|
||||||
*
|
|
||||||
* heap: the table containing the new tuple
|
|
||||||
* index: the index supporting the exclusion constraint
|
|
||||||
* indexInfo: info about the index, including the exclusion properties
|
|
||||||
* tupleid: heap TID of the new tuple we have just inserted
|
|
||||||
* values, isnull: the *index* column values computed for the new tuple
|
|
||||||
* estate: an EState we can do evaluation in
|
|
||||||
* newIndex: if true, we are trying to build a new index (this affects
|
|
||||||
* only the wording of error messages)
|
|
||||||
* errorOK: if true, don't throw error for violation
|
|
||||||
*
|
|
||||||
* Returns true if OK, false if actual or potential violation
|
|
||||||
*
|
|
||||||
* When errorOK is true, we report violation without waiting to see if any
|
|
||||||
* concurrent transaction has committed or not; so the violation is only
|
|
||||||
* potential, and the caller must recheck sometime later. This behavior
|
|
||||||
* is convenient for deferred exclusion checks; we need not bother queuing
|
|
||||||
* a deferred event if there is definitely no conflict at insertion time.
|
|
||||||
*
|
|
||||||
* When errorOK is false, we'll throw error on violation, so a false result
|
|
||||||
* is impossible.
|
|
||||||
*/
|
|
||||||
bool
|
|
||||||
check_exclusion_constraint(Relation heap, Relation index, IndexInfo *indexInfo,
|
|
||||||
ItemPointer tupleid, Datum *values, bool *isnull,
|
|
||||||
EState *estate, bool newIndex, bool errorOK)
|
|
||||||
{
|
|
||||||
Oid *constr_procs = indexInfo->ii_ExclusionProcs;
|
|
||||||
uint16 *constr_strats = indexInfo->ii_ExclusionStrats;
|
|
||||||
Oid *index_collations = index->rd_indcollation;
|
|
||||||
int index_natts = index->rd_index->indnatts;
|
|
||||||
IndexScanDesc index_scan;
|
|
||||||
HeapTuple tup;
|
|
||||||
ScanKeyData scankeys[INDEX_MAX_KEYS];
|
|
||||||
SnapshotData DirtySnapshot;
|
|
||||||
int i;
|
|
||||||
bool conflict;
|
|
||||||
bool found_self;
|
|
||||||
ExprContext *econtext;
|
|
||||||
TupleTableSlot *existing_slot;
|
|
||||||
TupleTableSlot *save_scantuple;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 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 < index_natts; 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 < index_natts; 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 = MakeSingleTupleTableSlot(RelationGetDescr(heap));
|
|
||||||
|
|
||||||
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, index_natts, 0);
|
|
||||||
index_rescan(index_scan, scankeys, index_natts, NULL, 0);
|
|
||||||
|
|
||||||
while ((tup = index_getnext(index_scan,
|
|
||||||
ForwardScanDirection)) != NULL)
|
|
||||||
{
|
|
||||||
TransactionId xwait;
|
|
||||||
ItemPointerData ctid_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 (ItemPointerEquals(tupleid, &tup->t_self))
|
|
||||||
{
|
|
||||||
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.
|
|
||||||
*/
|
|
||||||
ExecStoreTuple(tup, existing_slot, InvalidBuffer, false);
|
|
||||||
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
|
|
||||||
* we're not supposed to raise error, just return the fact of the
|
|
||||||
* potential conflict without waiting to see if it's real.
|
|
||||||
*/
|
|
||||||
if (errorOK)
|
|
||||||
{
|
|
||||||
conflict = true;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If an in-progress transaction is affecting the visibility of this
|
|
||||||
* tuple, we need to wait for it to complete and then recheck. 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))
|
|
||||||
{
|
|
||||||
ctid_wait = tup->t_data->t_ctid;
|
|
||||||
index_endscan(index_scan);
|
|
||||||
XactLockTableWait(xwait, heap, &ctid_wait,
|
|
||||||
XLTW_RecheckExclusionConstr);
|
|
||||||
goto retry;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* We have a definite conflict. Report it.
|
|
||||||
*/
|
|
||||||
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, 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;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Check existing tuple's index values to see if it really matches the
|
|
||||||
* exclusion condition against the new_values. Returns true if conflict.
|
|
||||||
*/
|
|
||||||
static bool
|
|
||||||
index_recheck_constraint(Relation index, Oid *constr_procs,
|
|
||||||
Datum *existing_values, bool *existing_isnull,
|
|
||||||
Datum *new_values)
|
|
||||||
{
|
|
||||||
int index_natts = index->rd_index->indnatts;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for (i = 0; i < index_natts; 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;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* UpdateChangedParamSet
|
* UpdateChangedParamSet
|
||||||
* Add changed parameters to a plan node's chgParam set
|
* Add changed parameters to a plan node's chgParam set
|
||||||
|
|||||||
@ -351,6 +351,16 @@ extern bool ExecRelationIsTargetRelation(EState *estate, Index scanrelid);
|
|||||||
extern Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags);
|
extern Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags);
|
||||||
extern void ExecCloseScanRelation(Relation scanrel);
|
extern void ExecCloseScanRelation(Relation scanrel);
|
||||||
|
|
||||||
|
extern void RegisterExprContextCallback(ExprContext *econtext,
|
||||||
|
ExprContextCallbackFunction function,
|
||||||
|
Datum arg);
|
||||||
|
extern void UnregisterExprContextCallback(ExprContext *econtext,
|
||||||
|
ExprContextCallbackFunction function,
|
||||||
|
Datum arg);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* prototypes from functions in execIndexing.c
|
||||||
|
*/
|
||||||
extern void ExecOpenIndices(ResultRelInfo *resultRelInfo);
|
extern void ExecOpenIndices(ResultRelInfo *resultRelInfo);
|
||||||
extern void ExecCloseIndices(ResultRelInfo *resultRelInfo);
|
extern void ExecCloseIndices(ResultRelInfo *resultRelInfo);
|
||||||
extern List *ExecInsertIndexTuples(TupleTableSlot *slot, ItemPointer tupleid,
|
extern List *ExecInsertIndexTuples(TupleTableSlot *slot, ItemPointer tupleid,
|
||||||
@ -362,11 +372,5 @@ extern bool check_exclusion_constraint(Relation heap, Relation index,
|
|||||||
EState *estate,
|
EState *estate,
|
||||||
bool newIndex, bool errorOK);
|
bool newIndex, bool errorOK);
|
||||||
|
|
||||||
extern void RegisterExprContextCallback(ExprContext *econtext,
|
|
||||||
ExprContextCallbackFunction function,
|
|
||||||
Datum arg);
|
|
||||||
extern void UnregisterExprContextCallback(ExprContext *econtext,
|
|
||||||
ExprContextCallbackFunction function,
|
|
||||||
Datum arg);
|
|
||||||
|
|
||||||
#endif /* EXECUTOR_H */
|
#endif /* EXECUTOR_H */
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user