mirror of
https://github.com/postgres/postgres.git
synced 2025-06-29 10:41:53 +03:00
pgindent run for 9.0
This commit is contained in:
Bruce Momjian
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.170 2010/02/08 04:33:54 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.171 2010/02/26 02:00:41 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -342,7 +342,7 @@ CreateStandaloneExprContext(void)
|
||||
* any previously computed pass-by-reference expression result will go away!
|
||||
*
|
||||
* If isCommit is false, we are being called in error cleanup, and should
|
||||
* not call callbacks but only release memory. (It might be better to call
|
||||
* not call callbacks but only release memory. (It might be better to call
|
||||
* the callbacks and pass the isCommit flag to them, but that would require
|
||||
* more invasive code changes than currently seems justified.)
|
||||
*
|
||||
@ -1078,9 +1078,9 @@ ExecInsertIndexTuples(TupleTableSlot *slot,
|
||||
checkUnique = UNIQUE_CHECK_PARTIAL;
|
||||
|
||||
satisfiesConstraint =
|
||||
index_insert(indexRelation, /* index relation */
|
||||
values, /* array of index Datums */
|
||||
isnull, /* null flags */
|
||||
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 */
|
||||
@ -1088,7 +1088,7 @@ ExecInsertIndexTuples(TupleTableSlot *slot,
|
||||
/*
|
||||
* 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,
|
||||
* 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.
|
||||
*
|
||||
@ -1098,7 +1098,7 @@ ExecInsertIndexTuples(TupleTableSlot *slot,
|
||||
*/
|
||||
if (indexInfo->ii_ExclusionOps != NULL)
|
||||
{
|
||||
bool errorOK = !indexRelation->rd_index->indimmediate;
|
||||
bool errorOK = !indexRelation->rd_index->indimmediate;
|
||||
|
||||
satisfiesConstraint =
|
||||
check_exclusion_constraint(heapRelation,
|
||||
@ -1152,23 +1152,23 @@ 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;
|
||||
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;
|
||||
Oid *constr_procs = indexInfo->ii_ExclusionProcs;
|
||||
uint16 *constr_strats = indexInfo->ii_ExclusionStrats;
|
||||
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).
|
||||
* 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++)
|
||||
{
|
||||
@ -1177,8 +1177,8 @@ check_exclusion_constraint(Relation heap, Relation index, IndexInfo *indexInfo,
|
||||
}
|
||||
|
||||
/*
|
||||
* Search the tuples that are in the index for any violations,
|
||||
* including tuples that aren't visible yet.
|
||||
* Search the tuples that are in the index for any violations, including
|
||||
* tuples that aren't visible yet.
|
||||
*/
|
||||
InitDirtySnapshot(DirtySnapshot);
|
||||
|
||||
@ -1205,8 +1205,8 @@ check_exclusion_constraint(Relation heap, Relation index, IndexInfo *indexInfo,
|
||||
econtext->ecxt_scantuple = existing_slot;
|
||||
|
||||
/*
|
||||
* May have to restart scan from this point if a potential
|
||||
* conflict is found.
|
||||
* May have to restart scan from this point if a potential conflict is
|
||||
* found.
|
||||
*/
|
||||
retry:
|
||||
conflict = false;
|
||||
@ -1217,11 +1217,11 @@ retry:
|
||||
while ((tup = index_getnext(index_scan,
|
||||
ForwardScanDirection)) != NULL)
|
||||
{
|
||||
TransactionId xwait;
|
||||
TransactionId xwait;
|
||||
Datum existing_values[INDEX_MAX_KEYS];
|
||||
bool existing_isnull[INDEX_MAX_KEYS];
|
||||
char *error_new;
|
||||
char *error_existing;
|
||||
char *error_new;
|
||||
char *error_existing;
|
||||
|
||||
/*
|
||||
* Ignore the entry for the tuple we're trying to check.
|
||||
@ -1239,7 +1239,7 @@ retry:
|
||||
* Extract the index column values and isnull flags from the existing
|
||||
* tuple.
|
||||
*/
|
||||
ExecStoreTuple(tup, existing_slot, InvalidBuffer, false);
|
||||
ExecStoreTuple(tup, existing_slot, InvalidBuffer, false);
|
||||
FormIndexDatum(indexInfo, existing_slot, estate,
|
||||
existing_values, existing_isnull);
|
||||
|
||||
@ -1251,12 +1251,13 @@ retry:
|
||||
existing_values,
|
||||
existing_isnull,
|
||||
values))
|
||||
continue; /* tuple doesn't actually match, so no conflict */
|
||||
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
|
||||
* 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)
|
||||
@ -1267,7 +1268,7 @@ retry:
|
||||
|
||||
/*
|
||||
* If an in-progress transaction is affecting the visibility of this
|
||||
* tuple, we need to wait for it to complete and then recheck. For
|
||||
* 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
|
||||
@ -1308,15 +1309,15 @@ retry:
|
||||
index_endscan(index_scan);
|
||||
|
||||
/*
|
||||
* We should have found our tuple in the index, unless we exited the
|
||||
* loop early because of conflict. Complain if not.
|
||||
* We should have found our tuple in the index, unless we exited the loop
|
||||
* early because of conflict. Complain if not.
|
||||
*/
|
||||
if (!found_self && !conflict)
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_INTERNAL_ERROR),
|
||||
errmsg("failed to re-find tuple within index \"%s\"",
|
||||
RelationGetRelationName(index)),
|
||||
errhint("This may be because of a non-immutable index expression.")));
|
||||
errhint("This may be because of a non-immutable index expression.")));
|
||||
|
||||
econtext->ecxt_scantuple = save_scantuple;
|
||||
|
||||
@ -1327,7 +1328,7 @@ retry:
|
||||
|
||||
/*
|
||||
* Check existing tuple's index values to see if it really matches the
|
||||
* exclusion condition against the new_values. Returns true if conflict.
|
||||
* exclusion condition against the new_values. Returns true if conflict.
|
||||
*/
|
||||
static bool
|
||||
index_recheck_constraint(Relation index, Oid *constr_procs,
|
||||
|
||||
Reference in New Issue
Block a user