8000 Avoid serializability errors when locking a tuple with a committed up… · rtpg/postgres@166873d · GitHub
[go: up one dir, main page]
Skip to content

Commit 166873d

Browse files
alvherrealvherre
committed
Avoid serializability errors when locking a tuple with a committed update
When key-share locking a tuple that has been not-key-updated, and the update is a committed transaction, in some cases we raised serializability errors: ERROR: could not serialize access due to concurrent update Because the key-share doesn't conflict with the update, the error is unnecessary and inconsistent with the case that the update hasn't committed yet. This causes problems for some usage patterns, even if it can be claimed that it's sufficient to retry the aborted transaction: given a steady stream of updating transactions and a long locking transaction, the long transaction can be starved indefinitely despite multiple retries. To fix, we recognize that HeapTupleSatisfiesUpdate can return HeapTupleUpdated when an updating transaction has committed, and that we need to deal with that case exactly as if it were a non-committed update: verify whether the two operations conflict, and if not, carry on normally. If they do conflict, however, there is a difference: in the HeapTupleBeingUpdated case we can just sleep until the concurrent transaction is gone, while in the HeapTupleUpdated case this is not possible and we must raise an error instead. Per trouble report from Olivier Dony. In addition to a couple of test cases that verify the changed behavior, I added a test case to verify the behavior that remains unchanged, namely that errors are raised when a update that modifies the key is used. That must still generate serializability errors. One pre-existing test case changes behavior; per discussion, the new behavior is actually the desired one. Discussion: https://www.postgresql.org/message-id/560AA479.4080807@odoo.com https://www.postgresql.org/message-id/20151014164844.3019.25750@wrigleys.postgresql.org Backpatch to 9.3, where the problem appeared.
1 parent 3274e14 commit 166873d

File tree

9 files changed

+1401
-4
lines changed

9 files changed

+1401
-4
lines changed

‎src/backend/access/heap/heapam.c

Lines changed: 13 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -4194,7 +4194,7 @@ heap_lock_tuple(Relation relation, HeapTuple tuple,
41944194
UnlockReleaseBuffer(*buffer);
41954195
elog(ERROR, "attempted to lock invisible tuple");
41964196
}
4197-
else if (result == HeapTupleBeingUpdated)
4197+
else if (result == HeapTupleBeingUpdated || result == HeapTupleUpdated)
41984198
{
41994199
TransactionId xwait;
42004200
uint16 infomask;
@@ -4396,12 +4396,22 @@ heap_lock_tuple(Relation relation, HeapTuple tuple,
43964396
}
43974397

43984398
/*
4399+
* Time to sleep on the other transaction/multixact, if necessary.
4400+
*
4401+
* If the other transaction is an update that's already committed,
4402+
* then sleeping cannot possibly do any good: if we're required to
4403+
* sleep, get out to raise an error instead.
4404+
*
43994405
* By here, we either have already acquired the buffer exclusive lock,
44004406
* or we must wait for the locking transaction or multixact; so below
44014407
* we ensure that we grab buffer lock after the sleep.
44024408
*/
4403-
4404-
if (require_sleep)
4409+
if (require_sleep && result == HeapTupleUpdated)
4410+
{
4411+
LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
4412+
goto failed;
4413+
}
4414+
else if (require_sleep)
44054415
{
44064416
/*
44074417
* Acquire tuple lock to establish our priority for the tuple.

0 commit comments

Comments
 (0)
0