Andres Freund wrote:
> On 2013-12-16 17:43:37 -0300, Alvaro Herrera wrote:
> > Alvaro Herrera wrote:
> > 
> > > This POC patch changes the two places in HeapTupleSatisfiesUpdate that
> > > need to be touched for this to work.  This is probably too simplistic,
> > > in that I make the involved cases return HeapTupleBeingUpdated without
> > > checking that there actually are remote lockers, which is the case of
> > > concern.  I'm not yet sure if this is the final form of the fix, or
> > > instead we should expand the Multi (in the cases where there is a multi)
> > > and verify whether any lockers are transactions other than the current
> > > one.  As is, nothing seems to break, but I think that's probably just
> > > chance and should not be relied upon.
> > 
> > After playing with this, I think the reason this seems to work without
> > fail is that all callers of HeapTupleSatisfiesUpdate are already
> > prepared to deal with the case where HeapTupleBeingUpdated is returned
> > but there is no actual transaction that would block the operation.
> > So I think the proposed patch is okay, barring a few more comments.
> Are you sure? the various wait/nowait cases don't seem to handle that
> correctly.

Well, it would help if those cases weren't dead code.  Neither
heap_update nor heap_delete are ever called in the "no wait" case at
all.  Only heap_lock_tuple is, and I can't see any misbehavior there
either, even with HeapTupleBeingUpdated returned when there's a
non-local locker, or when there's a MultiXact as xmax, regardless of its

Don't get me wrong --- it's not like this case is all that difficult to
handle.  All that's required is something like this in

        if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tuple)))
            if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))    /* not deleter 
                if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
                    int        nmembers;
                    bool    remote;
                    int        i;
                    MultiXactMember *members;

                    nmembers =
                                              &members, false);
                    remote = false;
                    for (i = 0; i < nmembers; i++)
                            remote = true;
                    if (nmembers > 0)

                    if (remote)
                        return HeapTupleBeingUpdated;
                        return HeapTupleMayBeUpdated;
                else if 
                    return HeapTupleBeingUpdated;
                return HeapTupleMayBeUpdated;

The simpler code just does away with the GetMultiXactIdMembers() and
returns HeapTupleBeingUpdated always.  In absence of a test case that
misbehaves with that, it's hard to see that it is a good idea to go all
this effort there.

Álvaro Herrera      
PostgreSQL Development, 24x7 Support, Training & Services

Sent via pgsql-hackers mailing list (
To make changes to your subscription:

Reply via email to