aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/backend/access/heap/heapam.c205
-rw-r--r--src/backend/access/heap/heapam_handler.c93
-rw-r--r--src/backend/access/table/tableam.c26
-rw-r--r--src/backend/commands/trigger.c55
-rw-r--r--src/backend/executor/execReplication.c19
-rw-r--r--src/backend/executor/nodeModifyTable.c353
-rw-r--r--src/include/access/heapam.h19
-rw-r--r--src/include/access/tableam.h73
-rw-r--r--src/include/commands/trigger.h4
9 files changed, 346 insertions, 501 deletions
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 7f642edf458..4a4cf76269d 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -2665,11 +2665,10 @@ xmax_infomask_changed(uint16 new_infomask, uint16 old_infomask)
}
/*
- * heap_delete - delete a tuple, optionally fetching it into a slot
+ * heap_delete - delete a tuple
*
* See table_tuple_delete() for an explanation of the parameters, except that
- * this routine directly takes a tuple rather than a slot. Also, we don't
- * place a lock on the tuple in this function, just fetch the existing version.
+ * this routine directly takes a tuple rather than a slot.
*
* In the failure cases, the routine fills *tmfd with the tuple's t_ctid,
* t_xmax (resolving a possible MultiXact, if necessary), and t_cmax (the last
@@ -2678,9 +2677,8 @@ xmax_infomask_changed(uint16 new_infomask, uint16 old_infomask)
*/
TM_Result
heap_delete(Relation relation, ItemPointer tid,
- CommandId cid, Snapshot crosscheck, int options,
- TM_FailureData *tmfd, bool changingPart,
- TupleTableSlot *oldSlot)
+ CommandId cid, Snapshot crosscheck, bool wait,
+ TM_FailureData *tmfd, bool changingPart)
{
TM_Result result;
TransactionId xid = GetCurrentTransactionId();
@@ -2758,7 +2756,7 @@ l1:
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("attempted to delete invisible tuple")));
}
- else if (result == TM_BeingModified && (options & TABLE_MODIFY_WAIT))
+ else if (result == TM_BeingModified && wait)
{
TransactionId xwait;
uint16 infomask;
@@ -2899,30 +2897,7 @@ l1:
tmfd->cmax = HeapTupleHeaderGetCmax(tp.t_data);
else
tmfd->cmax = InvalidCommandId;
-
- /*
- * If we're asked to lock the updated tuple, we just fetch the
- * existing tuple. That let's the caller save some resources on
- * placing the lock.
- */
- if (result == TM_Updated &&
- (options & TABLE_MODIFY_LOCK_UPDATED))
- {
- BufferHeapTupleTableSlot *bslot;
-
- Assert(TTS_IS_BUFFERTUPLE(oldSlot));
- bslot = (BufferHeapTupleTableSlot *) oldSlot;
-
- LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
- bslot->base.tupdata = tp;
- ExecStorePinnedBufferHeapTuple(&bslot->base.tupdata,
- oldSlot,
- buffer);
- }
- else
- {
- UnlockReleaseBuffer(buffer);
- }
+ UnlockReleaseBuffer(buffer);
if (have_tuple_lock)
UnlockTupleTuplock(relation, &(tp.t_self), LockTupleExclusive);
if (vmbuffer != InvalidBuffer)
@@ -3096,24 +3071,8 @@ l1:
*/
CacheInvalidateHeapTuple(relation, &tp, NULL);
- /* Fetch the old tuple version if we're asked for that. */
- if (options & TABLE_MODIFY_FETCH_OLD_TUPLE)
- {
- BufferHeapTupleTableSlot *bslot;
-
- Assert(TTS_IS_BUFFERTUPLE(oldSlot));
- bslot = (BufferHeapTupleTableSlot *) oldSlot;
-
- bslot->base.tupdata = tp;
- ExecStorePinnedBufferHeapTuple(&bslot->base.tupdata,
- oldSlot,
- buffer);
- }
- else
- {
- /* Now we can release the buffer */
- ReleaseBuffer(buffer);
- }
+ /* Now we can release the buffer */
+ ReleaseBuffer(buffer);
/*
* Release the lmgr tuple lock, if we had it.
@@ -3145,8 +3104,8 @@ simple_heap_delete(Relation relation, ItemPointer tid)
result = heap_delete(relation, tid,
GetCurrentCommandId(true), InvalidSnapshot,
- TABLE_MODIFY_WAIT /* wait for commit */ ,
- &tmfd, false /* changingPart */ , NULL);
+ true /* wait for commit */ ,
+ &tmfd, false /* changingPart */ );
switch (result)
{
case TM_SelfModified:
@@ -3173,11 +3132,10 @@ simple_heap_delete(Relation relation, ItemPointer tid)
}
/*
- * heap_update - replace a tuple, optionally fetching it into a slot
+ * heap_update - replace a tuple
*
* See table_tuple_update() for an explanation of the parameters, except that
- * this routine directly takes a tuple rather than a slot. Also, we don't
- * place a lock on the tuple in this function, just fetch the existing version.
+ * this routine directly takes a tuple rather than a slot.
*
* In the failure cases, the routine fills *tmfd with the tuple's t_ctid,
* t_xmax (resolving a possible MultiXact, if necessary), and t_cmax (the last
@@ -3186,9 +3144,9 @@ simple_heap_delete(Relation relation, ItemPointer tid)
*/
TM_Result
heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
- CommandId cid, Snapshot crosscheck, int options,
+ CommandId cid, Snapshot crosscheck, bool wait,
TM_FailureData *tmfd, LockTupleMode *lockmode,
- TU_UpdateIndexes *update_indexes, TupleTableSlot *oldSlot)
+ TU_UpdateIndexes *update_indexes)
{
TM_Result result;
TransactionId xid = GetCurrentTransactionId();
@@ -3365,7 +3323,7 @@ l2:
result = HeapTupleSatisfiesUpdate(&oldtup, cid, buffer);
/* see below about the "no wait" case */
- Assert(result != TM_BeingModified || (options & TABLE_MODIFY_WAIT));
+ Assert(result != TM_BeingModified || wait);
if (result == TM_Invisible)
{
@@ -3374,7 +3332,7 @@ l2:
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("attempted to update invisible tuple")));
}
- else if (result == TM_BeingModified && (options & TABLE_MODIFY_WAIT))
+ else if (result == TM_BeingModified && wait)
{
TransactionId xwait;
uint16 infomask;
@@ -3578,30 +3536,7 @@ l2:
tmfd->cmax = HeapTupleHeaderGetCmax(oldtup.t_data);
else
tmfd->cmax = InvalidCommandId;
-
- /*
- * If we're asked to lock the updated tuple, we just fetch the
- * existing tuple. That lets the caller save some resources on
- * placing the lock.
- */
- if (result == TM_Updated &&
- (options & TABLE_MODIFY_LOCK_UPDATED))
- {
- BufferHeapTupleTableSlot *bslot;
-
- Assert(TTS_IS_BUFFERTUPLE(oldSlot));
- bslot = (BufferHeapTupleTableSlot *) oldSlot;
-
- LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
- bslot->base.tupdata = oldtup;
- ExecStorePinnedBufferHeapTuple(&bslot->base.tupdata,
- oldSlot,
- buffer);
- }
- else
- {
- UnlockReleaseBuffer(buffer);
- }
+ UnlockReleaseBuffer(buffer);
if (have_tuple_lock)
UnlockTupleTuplock(relation, &(oldtup.t_self), *lockmode);
if (vmbuffer != InvalidBuffer)
@@ -4080,26 +4015,7 @@ l2:
/* Now we can release the buffer(s) */
if (newbuf != buffer)
ReleaseBuffer(newbuf);
-
- /* Fetch the old tuple version if we're asked for that. */
- if (options & TABLE_MODIFY_FETCH_OLD_TUPLE)
- {
- BufferHeapTupleTableSlot *bslot;
-
- Assert(TTS_IS_BUFFERTUPLE(oldSlot));
- bslot = (BufferHeapTupleTableSlot *) oldSlot;
-
- bslot->base.tupdata = oldtup;
- ExecStorePinnedBufferHeapTuple(&bslot->base.tupdata,
- oldSlot,
- buffer);
- }
- else
- {
- /* Now we can release the buffer */
- ReleaseBuffer(buffer);
- }
-
+ ReleaseBuffer(buffer);
if (BufferIsValid(vmbuffer_new))
ReleaseBuffer(vmbuffer_new);
if (BufferIsValid(vmbuffer))
@@ -4307,8 +4223,8 @@ simple_heap_update(Relation relation, ItemPointer otid, HeapTuple tup,
result = heap_update(relation, otid, tup,
GetCurrentCommandId(true), InvalidSnapshot,
- TABLE_MODIFY_WAIT /* wait for commit */ ,
- &tmfd, &lockmode, update_indexes, NULL);
+ true /* wait for commit */ ,
+ &tmfd, &lockmode, update_indexes);
switch (result)
{
case TM_SelfModified:
@@ -4371,14 +4287,12 @@ get_mxact_status_for_lock(LockTupleMode mode, bool is_update)
* tuples.
*
* Output parameters:
- * *slot: BufferHeapTupleTableSlot filled with tuple
+ * *tuple: all fields filled in
+ * *buffer: set to buffer holding tuple (pinned but not locked at exit)
* *tmfd: filled in failure cases (see below)
*
* Function results are the same as the ones for table_tuple_lock().
*
- * If *slot already contains the target tuple, it takes advantage on that by
- * skipping the ReadBuffer() call.
- *
* In the failure cases other than TM_Invisible, the routine fills
* *tmfd with the tuple's t_ctid, t_xmax (resolving a possible MultiXact,
* if necessary), and t_cmax (the last only for TM_SelfModified,
@@ -4389,14 +4303,15 @@ get_mxact_status_for_lock(LockTupleMode mode, bool is_update)
* See README.tuplock for a thorough explanation of this mechanism.
*/
TM_Result
-heap_lock_tuple(Relation relation, ItemPointer tid, TupleTableSlot *slot,
+heap_lock_tuple(Relation relation, HeapTuple tuple,
CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy,
- bool follow_updates, TM_FailureData *tmfd)
+ bool follow_updates,
+ Buffer *buffer, TM_FailureData *tmfd)
{
TM_Result result;
+ ItemPointer tid = &(tuple->t_self);
ItemId lp;
Page page;
- Buffer buffer;
Buffer vmbuffer = InvalidBuffer;
BlockNumber block;
TransactionId xid,
@@ -4408,24 +4323,8 @@ heap_lock_tuple(Relation relation, ItemPointer tid, TupleTableSlot *slot,
bool skip_tuple_lock = false;
bool have_tuple_lock = false;
bool cleared_all_frozen = false;
- BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
- HeapTuple tuple = &bslot->base.tupdata;
-
- Assert(TTS_IS_BUFFERTUPLE(slot));
- /* Take advantage if slot already contains the relevant tuple */
- if (!TTS_EMPTY(slot) &&
- slot->tts_tableOid == relation->rd_id &&
- ItemPointerCompare(&slot->tts_tid, tid) == 0 &&
- BufferIsValid(bslot->buffer))
- {
- buffer = bslot->buffer;
- IncrBufferRefCount(buffer);
- }
- else
- {
- buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
- }
+ *buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
block = ItemPointerGetBlockNumber(tid);
/*
@@ -4434,22 +4333,21 @@ heap_lock_tuple(Relation relation, ItemPointer tid, TupleTableSlot *slot,
* in the middle of changing this, so we'll need to recheck after we have
* the lock.
*/
- if (PageIsAllVisible(BufferGetPage(buffer)))
+ if (PageIsAllVisible(BufferGetPage(*buffer)))
visibilitymap_pin(relation, block, &vmbuffer);
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(*buffer);
lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
Assert(ItemIdIsNormal(lp));
- tuple->t_self = *tid;
tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
tuple->t_len = ItemIdGetLength(lp);
tuple->t_tableOid = RelationGetRelid(relation);
l3:
- result = HeapTupleSatisfiesUpdate(tuple, cid, buffer);
+ result = HeapTupleSatisfiesUpdate(tuple, cid, *buffer);
if (result == TM_Invisible)
{
@@ -4478,7 +4376,7 @@ l3:
infomask2 = tuple->t_data->t_infomask2;
ItemPointerCopy(&tuple->t_data->t_ctid, &t_ctid);
- LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
/*
* If any subtransaction of the current top transaction already holds
@@ -4630,12 +4528,12 @@ l3:
{
result = res;
/* recovery code expects to have buffer lock held */
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
goto failed;
}
}
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
/*
* Make sure it's still an appropriate lock, else start over.
@@ -4670,7 +4568,7 @@ l3:
if (HEAP_XMAX_IS_LOCKED_ONLY(infomask) &&
!HEAP_XMAX_IS_EXCL_LOCKED(infomask))
{
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
/*
* Make sure it's still an appropriate lock, else start over.
@@ -4698,7 +4596,7 @@ l3:
* No conflict, but if the xmax changed under us in the
* meantime, start over.
*/
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
!TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
xwait))
@@ -4710,7 +4608,7 @@ l3:
}
else if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask))
{
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
/* if the xmax changed in the meantime, start over */
if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
@@ -4738,7 +4636,7 @@ l3:
TransactionIdIsCurrentTransactionId(xwait))
{
/* ... but if the xmax changed in the meantime, start over */
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
!TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
xwait))
@@ -4760,7 +4658,7 @@ l3:
*/
if (require_sleep && (result == TM_Updated || result == TM_Deleted))
{
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
goto failed;
}
else if (require_sleep)
@@ -4785,7 +4683,7 @@ l3:
*/
result = TM_WouldBlock;
/* recovery code expects to have buffer lock held */
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
goto failed;
}
@@ -4811,7 +4709,7 @@ l3:
{
result = TM_WouldBlock;
/* recovery code expects to have buffer lock held */
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
goto failed;
}
break;
@@ -4851,7 +4749,7 @@ l3:
{
result = TM_WouldBlock;
/* recovery code expects to have buffer lock held */
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
goto failed;
}
break;
@@ -4877,12 +4775,12 @@ l3:
{
result = res;
/* recovery code expects to have buffer lock held */
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
goto failed;
}
}
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
/*
* xwait is done, but if xwait had just locked the tuple then some
@@ -4904,7 +4802,7 @@ l3:
* don't check for this in the multixact case, because some
* locker transactions might still be running.
*/
- UpdateXmaxHintBits(tuple->t_data, buffer, xwait);
+ UpdateXmaxHintBits(tuple->t_data, *buffer, xwait);
}
}
@@ -4963,9 +4861,9 @@ failed:
*/
if (vmbuffer == InvalidBuffer && PageIsAllVisible(page))
{
- LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
visibilitymap_pin(relation, block, &vmbuffer);
- LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
goto l3;
}
@@ -5028,7 +4926,7 @@ failed:
cleared_all_frozen = true;
- MarkBufferDirty(buffer);
+ MarkBufferDirty(*buffer);
/*
* XLOG stuff. You might think that we don't need an XLOG record because
@@ -5048,7 +4946,7 @@ failed:
XLogRecPtr recptr;
XLogBeginInsert();
- XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
+ XLogRegisterBuffer(0, *buffer, REGBUF_STANDARD);
xlrec.offnum = ItemPointerGetOffsetNumber(&tuple->t_self);
xlrec.xmax = xid;
@@ -5069,7 +4967,7 @@ failed:
result = TM_Ok;
out_locked:
- LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
out_unlocked:
if (BufferIsValid(vmbuffer))
@@ -5087,9 +4985,6 @@ out_unlocked:
if (have_tuple_lock)
UnlockTupleTuplock(relation, tid, mode);
- /* Put the target tuple to the slot */
- ExecStorePinnedBufferHeapTuple(tuple, slot, buffer);
-
return result;
}
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 00d82705327..cf41ab239ed 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -46,11 +46,6 @@
#include "utils/builtins.h"
#include "utils/rel.h"
-static TM_Result heapam_tuple_lock(Relation relation, ItemPointer tid,
- Snapshot snapshot, TupleTableSlot *slot,
- CommandId cid, LockTupleMode mode,
- LockWaitPolicy wait_policy, uint8 flags,
- TM_FailureData *tmfd);
static void reform_and_rewrite_tuple(HeapTuple tuple,
Relation OldHeap, Relation NewHeap,
Datum *values, bool *isnull, RewriteState rwstate);
@@ -306,55 +301,23 @@ heapam_tuple_complete_speculative(Relation relation, TupleTableSlot *slot,
static TM_Result
heapam_tuple_delete(Relation relation, ItemPointer tid, CommandId cid,
- Snapshot snapshot, Snapshot crosscheck, int options,
- TM_FailureData *tmfd, bool changingPart,
- TupleTableSlot *oldSlot)
+ Snapshot snapshot, Snapshot crosscheck, bool wait,
+ TM_FailureData *tmfd, bool changingPart)
{
- TM_Result result;
-
/*
* Currently Deleting of index tuples are handled at vacuum, in case if
* the storage itself is cleaning the dead tuples by itself, it is the
* time to call the index tuple deletion also.
*/
- result = heap_delete(relation, tid, cid, crosscheck, options,
- tmfd, changingPart, oldSlot);
-
- /*
- * If the tuple has been concurrently updated, then get the lock on it.
- * (Do only if caller asked for this by setting the
- * TABLE_MODIFY_LOCK_UPDATED option) With the lock held retry of the
- * delete should succeed even if there are more concurrent update
- * attempts.
- */
- if (result == TM_Updated && (options & TABLE_MODIFY_LOCK_UPDATED))
- {
- /*
- * heapam_tuple_lock() will take advantage of tuple loaded into
- * oldSlot by heap_delete().
- */
- result = heapam_tuple_lock(relation, tid, snapshot,
- oldSlot, cid, LockTupleExclusive,
- (options & TABLE_MODIFY_WAIT) ?
- LockWaitBlock :
- LockWaitSkip,
- TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
- tmfd);
-
- if (result == TM_Ok)
- return TM_Updated;
- }
-
- return result;
+ return heap_delete(relation, tid, cid, crosscheck, wait, tmfd, changingPart);
}
static TM_Result
heapam_tuple_update(Relation relation, ItemPointer otid, TupleTableSlot *slot,
CommandId cid, Snapshot snapshot, Snapshot crosscheck,
- int options, TM_FailureData *tmfd,
- LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes,
- TupleTableSlot *oldSlot)
+ bool wait, TM_FailureData *tmfd,
+ LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)
{
bool shouldFree = true;
HeapTuple tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFree);
@@ -364,8 +327,8 @@ heapam_tuple_update(Relation relation, ItemPointer otid, TupleTableSlot *slot,
slot->tts_tableOid = RelationGetRelid(relation);
tuple->t_tableOid = slot->tts_tableOid;
- result = heap_update(relation, otid, tuple, cid, crosscheck, options,
- tmfd, lockmode, update_indexes, oldSlot);
+ result = heap_update(relation, otid, tuple, cid, crosscheck, wait,
+ tmfd, lockmode, update_indexes);
ItemPointerCopy(&tuple->t_self, &slot->tts_tid);
/*
@@ -392,31 +355,6 @@ heapam_tuple_update(Relation relation, ItemPointer otid, TupleTableSlot *slot,
if (shouldFree)
pfree(tuple);
- /*
- * If the tuple has been concurrently updated, then get the lock on it.
- * (Do only if caller asked for this by setting the
- * TABLE_MODIFY_LOCK_UPDATED option) With the lock held retry of the
- * update should succeed even if there are more concurrent update
- * attempts.
- */
- if (result == TM_Updated && (options & TABLE_MODIFY_LOCK_UPDATED))
- {
- /*
- * heapam_tuple_lock() will take advantage of tuple loaded into
- * oldSlot by heap_update().
- */
- result = heapam_tuple_lock(relation, otid, snapshot,
- oldSlot, cid, *lockmode,
- (options & TABLE_MODIFY_WAIT) ?
- LockWaitBlock :
- LockWaitSkip,
- TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
- tmfd);
-
- if (result == TM_Ok)
- return TM_Updated;
- }
-
return result;
}
@@ -428,6 +366,7 @@ heapam_tuple_lock(Relation relation, ItemPointer tid, Snapshot snapshot,
{
BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
TM_Result result;
+ Buffer buffer;
HeapTuple tuple = &bslot->base.tupdata;
bool follow_updates;
@@ -437,8 +376,9 @@ heapam_tuple_lock(Relation relation, ItemPointer tid, Snapshot snapshot,
Assert(TTS_IS_BUFFERTUPLE(slot));
tuple_lock_retry:
- result = heap_lock_tuple(relation, tid, slot, cid, mode, wait_policy,
- follow_updates, tmfd);
+ tuple->t_self = *tid;
+ result = heap_lock_tuple(relation, tuple, cid, mode, wait_policy,
+ follow_updates, &buffer, tmfd);
if (result == TM_Updated &&
(flags & TUPLE_LOCK_FLAG_FIND_LAST_VERSION))
@@ -446,6 +386,8 @@ tuple_lock_retry:
/* Should not encounter speculative tuple on recheck */
Assert(!HeapTupleHeaderIsSpeculative(tuple->t_data));
+ ReleaseBuffer(buffer);
+
if (!ItemPointerEquals(&tmfd->ctid, &tuple->t_self))
{
SnapshotData SnapshotDirty;
@@ -467,8 +409,6 @@ tuple_lock_retry:
InitDirtySnapshot(SnapshotDirty);
for (;;)
{
- Buffer buffer = InvalidBuffer;
-
if (ItemPointerIndicatesMovedPartitions(tid))
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
@@ -563,7 +503,7 @@ tuple_lock_retry:
/*
* This is a live tuple, so try to lock it again.
*/
- ExecStorePinnedBufferHeapTuple(tuple, slot, buffer);
+ ReleaseBuffer(buffer);
goto tuple_lock_retry;
}
@@ -574,7 +514,7 @@ tuple_lock_retry:
*/
if (tuple->t_data == NULL)
{
- ReleaseBuffer(buffer);
+ Assert(!BufferIsValid(buffer));
return TM_Deleted;
}
@@ -627,6 +567,9 @@ tuple_lock_retry:
slot->tts_tableOid = RelationGetRelid(relation);
tuple->t_tableOid = slot->tts_tableOid;
+ /* store in slot, transferring existing pin */
+ ExecStorePinnedBufferHeapTuple(tuple, slot, buffer);
+
return result;
}
diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
index 8d3675be959..e57a0b7ea31 100644
--- a/src/backend/access/table/tableam.c
+++ b/src/backend/access/table/tableam.c
@@ -287,23 +287,16 @@ simple_table_tuple_insert(Relation rel, TupleTableSlot *slot)
* via ereport().
*/
void
-simple_table_tuple_delete(Relation rel, ItemPointer tid, Snapshot snapshot,
- TupleTableSlot *oldSlot)
+simple_table_tuple_delete(Relation rel, ItemPointer tid, Snapshot snapshot)
{
TM_Result result;
TM_FailureData tmfd;
- int options = TABLE_MODIFY_WAIT; /* wait for commit */
-
- /* Fetch old tuple if the relevant slot is provided */
- if (oldSlot)
- options |= TABLE_MODIFY_FETCH_OLD_TUPLE;
result = table_tuple_delete(rel, tid,
GetCurrentCommandId(true),
snapshot, InvalidSnapshot,
- options,
- &tmfd, false /* changingPart */ ,
- oldSlot);
+ true /* wait for commit */ ,
+ &tmfd, false /* changingPart */ );
switch (result)
{
@@ -342,24 +335,17 @@ void
simple_table_tuple_update(Relation rel, ItemPointer otid,
TupleTableSlot *slot,
Snapshot snapshot,
- TU_UpdateIndexes *update_indexes,
- TupleTableSlot *oldSlot)
+ TU_UpdateIndexes *update_indexes)
{
TM_Result result;
TM_FailureData tmfd;
LockTupleMode lockmode;
- int options = TABLE_MODIFY_WAIT; /* wait for commit */
-
- /* Fetch old tuple if the relevant slot is provided */
- if (oldSlot)
- options |= TABLE_MODIFY_FETCH_OLD_TUPLE;
result = table_tuple_update(rel, otid, slot,
GetCurrentCommandId(true),
snapshot, InvalidSnapshot,
- options,
- &tmfd, &lockmode, update_indexes,
- oldSlot);
+ true /* wait for commit */ ,
+ &tmfd, &lockmode, update_indexes);
switch (result)
{
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 84494c4b81f..35eb7180f7e 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -2773,8 +2773,8 @@ ExecBRDeleteTriggers(EState *estate, EPQState *epqstate,
void
ExecARDeleteTriggers(EState *estate,
ResultRelInfo *relinfo,
+ ItemPointer tupleid,
HeapTuple fdw_trigtuple,
- TupleTableSlot *slot,
TransitionCaptureState *transition_capture,
bool is_crosspart_update)
{
@@ -2783,11 +2783,20 @@ ExecARDeleteTriggers(EState *estate,
if ((trigdesc && trigdesc->trig_delete_after_row) ||
(transition_capture && transition_capture->tcs_delete_old_table))
{
- /*
- * Put the FDW old tuple to the slot. Otherwise, the caller is
- * expected to have an old tuple already fetched to the slot.
- */
- if (fdw_trigtuple != NULL)
+ TupleTableSlot *slot = ExecGetTriggerOldSlot(estate, relinfo);
+
+ Assert(HeapTupleIsValid(fdw_trigtuple) ^ ItemPointerIsValid(tupleid));
+ if (fdw_trigtuple == NULL)
+ GetTupleForTrigger(estate,
+ NULL,
+ relinfo,
+ tupleid,
+ LockTupleExclusive,
+ slot,
+ NULL,
+ NULL,
+ NULL);
+ else
ExecForceStoreHeapTuple(fdw_trigtuple, slot, false);
AfterTriggerSaveEvent(estate, relinfo, NULL, NULL,
@@ -3078,17 +3087,18 @@ ExecBRUpdateTriggers(EState *estate, EPQState *epqstate,
* Note: 'src_partinfo' and 'dst_partinfo', when non-NULL, refer to the source
* and destination partitions, respectively, of a cross-partition update of
* the root partitioned table mentioned in the query, given by 'relinfo'.
- * 'oldslot' contains the "old" tuple in the source partition, and 'newslot'
- * contains the "new" tuple in the destination partition. This interface
- * allows to support the requirements of ExecCrossPartitionUpdateForeignKey();
- * is_crosspart_update must be true in that case.
+ * 'tupleid' in that case refers to the ctid of the "old" tuple in the source
+ * partition, and 'newslot' contains the "new" tuple in the destination
+ * partition. This interface allows to support the requirements of
+ * ExecCrossPartitionUpdateForeignKey(); is_crosspart_update must be true in
+ * that case.
*/
void
ExecARUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
ResultRelInfo *src_partinfo,
ResultRelInfo *dst_partinfo,
+ ItemPointer tupleid,
HeapTuple fdw_trigtuple,
- TupleTableSlot *oldslot,
TupleTableSlot *newslot,
List *recheckIndexes,
TransitionCaptureState *transition_capture,
@@ -3107,14 +3117,29 @@ ExecARUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
* separately for DELETE and INSERT to capture transition table rows.
* In such case, either old tuple or new tuple can be NULL.
*/
+ TupleTableSlot *oldslot;
+ ResultRelInfo *tupsrc;
+
Assert((src_partinfo != NULL && dst_partinfo != NULL) ||
!is_crosspart_update);
- if (fdw_trigtuple != NULL)
- {
- Assert(oldslot);
+ tupsrc = src_partinfo ? src_partinfo : relinfo;
+ oldslot = ExecGetTriggerOldSlot(estate, tupsrc);
+
+ if (fdw_trigtuple == NULL && ItemPointerIsValid(tupleid))
+ GetTupleForTrigger(estate,
+ NULL,
+ tupsrc,
+ tupleid,
+ LockTupleExclusive,
+ oldslot,
+ NULL,
+ NULL,
+ NULL);
+ else if (fdw_trigtuple != NULL)
ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, false);
- }
+ else
+ ExecClearTuple(oldslot);
AfterTriggerSaveEvent(estate, relinfo,
src_partinfo, dst_partinfo,
diff --git a/src/backend/executor/execReplication.c b/src/backend/executor/execReplication.c
index 0cad843fb69..d0a89cd5778 100644
--- a/src/backend/executor/execReplication.c
+++ b/src/backend/executor/execReplication.c
@@ -577,7 +577,6 @@ ExecSimpleRelationUpdate(ResultRelInfo *resultRelInfo,
{
List *recheckIndexes = NIL;
TU_UpdateIndexes update_indexes;
- TupleTableSlot *oldSlot = NULL;
/* Compute stored generated columns */
if (rel->rd_att->constr &&
@@ -591,12 +590,8 @@ ExecSimpleRelationUpdate(ResultRelInfo *resultRelInfo,
if (rel->rd_rel->relispartition)
ExecPartitionCheck(resultRelInfo, slot, estate, true);
- if (resultRelInfo->ri_TrigDesc &&
- resultRelInfo->ri_TrigDesc->trig_update_after_row)
- oldSlot = ExecGetTriggerOldSlot(estate, resultRelInfo);
-
simple_table_tuple_update(rel, tid, slot, estate->es_snapshot,
- &update_indexes, oldSlot);
+ &update_indexes);
if (resultRelInfo->ri_NumIndices > 0 && (update_indexes != TU_None))
recheckIndexes = ExecInsertIndexTuples(resultRelInfo,
@@ -607,7 +602,7 @@ ExecSimpleRelationUpdate(ResultRelInfo *resultRelInfo,
/* AFTER ROW UPDATE Triggers */
ExecARUpdateTriggers(estate, resultRelInfo,
NULL, NULL,
- NULL, oldSlot, slot,
+ tid, NULL, slot,
recheckIndexes, NULL, false);
list_free(recheckIndexes);
@@ -641,18 +636,12 @@ ExecSimpleRelationDelete(ResultRelInfo *resultRelInfo,
if (!skip_tuple)
{
- TupleTableSlot *oldSlot = NULL;
-
- if (resultRelInfo->ri_TrigDesc &&
- resultRelInfo->ri_TrigDesc->trig_delete_after_row)
- oldSlot = ExecGetTriggerOldSlot(estate, resultRelInfo);
-
/* OK, delete the tuple */
- simple_table_tuple_delete(rel, tid, estate->es_snapshot, oldSlot);
+ simple_table_tuple_delete(rel, tid, estate->es_snapshot);
/* AFTER ROW DELETE Triggers */
ExecARDeleteTriggers(estate, resultRelInfo,
- NULL, oldSlot, NULL, false);
+ tid, NULL, NULL, false);
}
}
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 325d380b0a9..c570965da09 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -568,15 +568,6 @@ ExecInitInsertProjection(ModifyTableState *mtstate,
table_slot_create(resultRelInfo->ri_RelationDesc,
&estate->es_tupleTable);
- /*
- * In the ON CONFLICT UPDATE case, we will also need a slot for the old
- * tuple to calculate the updated tuple on its base.
- */
- if (node->onConflictAction == ONCONFLICT_UPDATE)
- resultRelInfo->ri_oldTupleSlot =
- table_slot_create(resultRelInfo->ri_RelationDesc,
- &estate->es_tupleTable);
-
/* Build ProjectionInfo if needed (it probably isn't). */
if (need_projection)
{
@@ -1165,7 +1156,7 @@ ExecInsert(ModifyTableContext *context,
ExecARUpdateTriggers(estate, resultRelInfo,
NULL, NULL,
NULL,
- resultRelInfo->ri_oldTupleSlot,
+ NULL,
slot,
NULL,
mtstate->mt_transition_capture,
@@ -1345,8 +1336,7 @@ ExecDeletePrologue(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
*/
static TM_Result
ExecDeleteAct(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
- ItemPointer tupleid, bool changingPart, int options,
- TupleTableSlot *oldSlot)
+ ItemPointer tupleid, bool changingPart)
{
EState *estate = context->estate;
@@ -1354,10 +1344,9 @@ ExecDeleteAct(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
estate->es_output_cid,
estate->es_snapshot,
estate->es_crosscheck_snapshot,
- options,
+ true /* wait for commit */ ,
&context->tmfd,
- changingPart,
- oldSlot);
+ changingPart);
}
/*
@@ -1366,15 +1355,10 @@ ExecDeleteAct(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
* Closing steps of tuple deletion; this invokes AFTER FOR EACH ROW triggers,
* including the UPDATE triggers if the deletion is being done as part of a
* cross-partition tuple move.
- *
- * The old tuple is already fetched into ‘slot’ for regular tables. For FDW,
- * the old tuple is given as 'oldtuple' and is to be stored in 'slot' when
- * needed.
*/
static void
ExecDeleteEpilogue(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
- ItemPointer tupleid, HeapTuple oldtuple,
- TupleTableSlot *slot, bool changingPart)
+ ItemPointer tupleid, HeapTuple oldtuple, bool changingPart)
{
ModifyTableState *mtstate = context->mtstate;
EState *estate = context->estate;
@@ -1392,8 +1376,8 @@ ExecDeleteEpilogue(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
{
ExecARUpdateTriggers(estate, resultRelInfo,
NULL, NULL,
- oldtuple,
- slot, NULL, NULL, mtstate->mt_transition_capture,
+ tupleid, oldtuple,
+ NULL, NULL, mtstate->mt_transition_capture,
false);
/*
@@ -1404,30 +1388,10 @@ ExecDeleteEpilogue(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
}
/* AFTER ROW DELETE Triggers */
- ExecARDeleteTriggers(estate, resultRelInfo, oldtuple, slot,
+ ExecARDeleteTriggers(estate, resultRelInfo, tupleid, oldtuple,
ar_delete_trig_tcs, changingPart);
}
-/*
- * Initializes the tuple slot in a ResultRelInfo for DELETE action.
- *
- * We mark 'projectNewInfoValid' even though the projections themselves
- * are not initialized here.
- */
-static void
-ExecInitDeleteTupleSlot(ModifyTableState *mtstate,
- ResultRelInfo *resultRelInfo)
-{
- EState *estate = mtstate->ps.state;
-
- Assert(!resultRelInfo->ri_projectNewInfoValid);
-
- resultRelInfo->ri_oldTupleSlot =
- table_slot_create(resultRelInfo->ri_RelationDesc,
- &estate->es_tupleTable);
- resultRelInfo->ri_projectNewInfoValid = true;
-}
-
/* ----------------------------------------------------------------
* ExecDelete
*
@@ -1447,8 +1411,7 @@ ExecInitDeleteTupleSlot(ModifyTableState *mtstate,
* part of an UPDATE of partition-key, then the slot returned by
* EvalPlanQual() is passed back using output parameter epqreturnslot.
*
- * Returns RETURNING result if any, otherwise NULL. The deleted tuple
- * to be stored into oldslot independently that.
+ * Returns RETURNING result if any, otherwise NULL.
* ----------------------------------------------------------------
*/
static TupleTableSlot *
@@ -1456,7 +1419,6 @@ ExecDelete(ModifyTableContext *context,
ResultRelInfo *resultRelInfo,
ItemPointer tupleid,
HeapTuple oldtuple,
- TupleTableSlot *oldslot,
bool processReturning,
bool changingPart,
bool canSetTag,
@@ -1520,15 +1482,6 @@ ExecDelete(ModifyTableContext *context,
}
else
{
- int options = TABLE_MODIFY_WAIT | TABLE_MODIFY_FETCH_OLD_TUPLE;
-
- /*
- * Specify that we need to lock and fetch the last tuple version for
- * EPQ on appropriate transaction isolation levels.
- */
- if (!IsolationUsesXactSnapshot())
- options |= TABLE_MODIFY_LOCK_UPDATED;
-
/*
* delete the tuple
*
@@ -1539,8 +1492,7 @@ ExecDelete(ModifyTableContext *context,
* transaction-snapshot mode transactions.
*/
ldelete:
- result = ExecDeleteAct(context, resultRelInfo, tupleid, changingPart,
- options, oldslot);
+ result = ExecDeleteAct(context, resultRelInfo, tupleid, changingPart);
if (tmresult)
*tmresult = result;
@@ -1587,6 +1539,7 @@ ldelete:
case TM_Updated:
{
+ TupleTableSlot *inputslot;
TupleTableSlot *epqslot;
if (IsolationUsesXactSnapshot())
@@ -1595,29 +1548,87 @@ ldelete:
errmsg("could not serialize access due to concurrent update")));
/*
- * We need to do EPQ. The latest tuple is already found
- * and locked as a result of TABLE_MODIFY_LOCK_UPDATED.
+ * Already know that we're going to need to do EPQ, so
+ * fetch tuple directly into the right slot.
*/
- Assert(context->tmfd.traversed);
- epqslot = EvalPlanQual(context->epqstate,
- resultRelationDesc,
- resultRelInfo->ri_RangeTableIndex,
- oldslot);
- if (TupIsNull(epqslot))
- /* Tuple not passing quals anymore, exiting... */
- return NULL;
+ EvalPlanQualBegin(context->epqstate);
+ inputslot = EvalPlanQualSlot(context->epqstate, resultRelationDesc,
+ resultRelInfo->ri_RangeTableIndex);
- /*
- * If requested, skip delete and pass back the updated
- * row.
- */
- if (epqreturnslot)
+ result = table_tuple_lock(resultRelationDesc, tupleid,
+ estate->es_snapshot,
+ inputslot, estate->es_output_cid,
+ LockTupleExclusive, LockWaitBlock,
+ TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
+ &context->tmfd);
+
+ switch (result)
{
- *epqreturnslot = epqslot;
- return NULL;
+ case TM_Ok:
+ Assert(context->tmfd.traversed);
+ epqslot = EvalPlanQual(context->epqstate,
+ resultRelationDesc,
+ resultRelInfo->ri_RangeTableIndex,
+ inputslot);
+ if (TupIsNull(epqslot))
+ /* Tuple not passing quals anymore, exiting... */
+ return NULL;
+
+ /*
+ * If requested, skip delete and pass back the
+ * updated row.
+ */
+ if (epqreturnslot)
+ {
+ *epqreturnslot = epqslot;
+ return NULL;
+ }
+ else
+ goto ldelete;
+
+ case TM_SelfModified:
+
+ /*
+ * This can be reached when following an update
+ * chain from a tuple updated by another session,
+ * reaching a tuple that was already updated in
+ * this transaction. If previously updated by this
+ * command, ignore the delete, otherwise error
+ * out.
+ *
+ * See also TM_SelfModified response to
+ * table_tuple_delete() above.
+ */
+ if (context->tmfd.cmax != estate->es_output_cid)
+ ereport(ERROR,
+ (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
+ errmsg("tuple to be deleted was already modified by an operation triggered by the current command"),
+ errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
+ return NULL;
+
+ case TM_Deleted:
+ /* tuple already deleted; nothing to do */
+ return NULL;
+
+ default:
+
+ /*
+ * TM_Invisible should be impossible because we're
+ * waiting for updated row versions, and would
+ * already have errored out if the first version
+ * is invisible.
+ *
+ * TM_Updated should be impossible, because we're
+ * locking the latest version via
+ * TUPLE_LOCK_FLAG_FIND_LAST_VERSION.
+ */
+ elog(ERROR, "unexpected table_tuple_lock status: %u",
+ result);
+ return NULL;
}
- else
- goto ldelete;
+
+ Assert(false);
+ break;
}
case TM_Deleted:
@@ -1651,8 +1662,7 @@ ldelete:
if (tupleDeleted)
*tupleDeleted = true;
- ExecDeleteEpilogue(context, resultRelInfo, tupleid, oldtuple,
- oldslot, changingPart);
+ ExecDeleteEpilogue(context, resultRelInfo, tupleid, oldtuple, changingPart);
/* Process RETURNING if present and if requested */
if (processReturning && resultRelInfo->ri_projectReturning)
@@ -1670,13 +1680,17 @@ ldelete:
}
else
{
- /* Copy old tuple to the returning slot */
slot = ExecGetReturningSlot(estate, resultRelInfo);
if (oldtuple != NULL)
+ {
ExecForceStoreHeapTuple(oldtuple, slot, false);
+ }
else
- ExecCopySlot(slot, oldslot);
- Assert(!TupIsNull(slot));
+ {
+ if (!table_tuple_fetch_row_version(resultRelationDesc, tupleid,
+ SnapshotAny, slot))
+ elog(ERROR, "failed to fetch deleted tuple for DELETE RETURNING");
+ }
}
rslot = ExecProcessReturning(resultRelInfo, slot, context->planSlot);
@@ -1777,18 +1791,11 @@ ExecCrossPartitionUpdate(ModifyTableContext *context,
}
/*
- * Make sure ri_oldTupleSlot is initialized. The old tuple is to be saved
- * there by ExecDelete() to save effort on further re-fetching.
- */
- if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
- ExecInitUpdateProjection(mtstate, resultRelInfo);
-
- /*
* Row movement, part 1. Delete the tuple, but skip RETURNING processing.
* We want to return rows from INSERT.
*/
ExecDelete(context, resultRelInfo,
- tupleid, oldtuple, resultRelInfo->ri_oldTupleSlot,
+ tupleid, oldtuple,
false, /* processReturning */
true, /* changingPart */
false, /* canSetTag */
@@ -1829,13 +1836,21 @@ ExecCrossPartitionUpdate(ModifyTableContext *context,
return true;
else
{
- /*
- * ExecDelete already fetches the most recent version of old tuple
- * to resultRelInfo->ri_oldTupleSlot. So, just project the new
- * tuple to retry the UPDATE with.
- */
+ /* Fetch the most recent version of old tuple. */
+ TupleTableSlot *oldSlot;
+
+ /* ... but first, make sure ri_oldTupleSlot is initialized. */
+ if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
+ ExecInitUpdateProjection(mtstate, resultRelInfo);
+ oldSlot = resultRelInfo->ri_oldTupleSlot;
+ if (!table_tuple_fetch_row_version(resultRelInfo->ri_RelationDesc,
+ tupleid,
+ SnapshotAny,
+ oldSlot))
+ elog(ERROR, "failed to fetch tuple being updated");
+ /* and project the new tuple to retry the UPDATE with */
*retry_slot = ExecGetUpdateNewTuple(resultRelInfo, epqslot,
- resultRelInfo->ri_oldTupleSlot);
+ oldSlot);
return false;
}
}
@@ -1954,8 +1969,7 @@ ExecUpdatePrepareSlot(ResultRelInfo *resultRelInfo,
static TM_Result
ExecUpdateAct(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
ItemPointer tupleid, HeapTuple oldtuple, TupleTableSlot *slot,
- bool canSetTag, int options, TupleTableSlot *oldSlot,
- UpdateContext *updateCxt)
+ bool canSetTag, UpdateContext *updateCxt)
{
EState *estate = context->estate;
Relation resultRelationDesc = resultRelInfo->ri_RelationDesc;
@@ -2047,8 +2061,7 @@ lreplace:
ExecCrossPartitionUpdateForeignKey(context,
resultRelInfo,
insert_destrel,
- tupleid,
- resultRelInfo->ri_oldTupleSlot,
+ tupleid, slot,
inserted_tuple);
return TM_Ok;
@@ -2091,10 +2104,9 @@ lreplace:
estate->es_output_cid,
estate->es_snapshot,
estate->es_crosscheck_snapshot,
- options /* wait for commit */ ,
+ true /* wait for commit */ ,
&context->tmfd, &updateCxt->lockmode,
- &updateCxt->updateIndexes,
- oldSlot);
+ &updateCxt->updateIndexes);
return result;
}
@@ -2108,8 +2120,7 @@ lreplace:
static void
ExecUpdateEpilogue(ModifyTableContext *context, UpdateContext *updateCxt,
ResultRelInfo *resultRelInfo, ItemPointer tupleid,
- HeapTuple oldtuple, TupleTableSlot *slot,
- TupleTableSlot *oldslot)
+ HeapTuple oldtuple, TupleTableSlot *slot)
{
ModifyTableState *mtstate = context->mtstate;
List *recheckIndexes = NIL;
@@ -2125,7 +2136,7 @@ ExecUpdateEpilogue(ModifyTableContext *context, UpdateContext *updateCxt,
/* AFTER ROW UPDATE Triggers */
ExecARUpdateTriggers(context->estate, resultRelInfo,
NULL, NULL,
- oldtuple, oldslot, slot,
+ tupleid, oldtuple, slot,
recheckIndexes,
mtstate->operation == CMD_INSERT ?
mtstate->mt_oc_transition_capture :
@@ -2214,7 +2225,7 @@ ExecCrossPartitionUpdateForeignKey(ModifyTableContext *context,
/* Perform the root table's triggers. */
ExecARUpdateTriggers(context->estate,
rootRelInfo, sourcePartInfo, destPartInfo,
- NULL, oldslot, newslot, NIL, NULL, true);
+ tupleid, NULL, newslot, NIL, NULL, true);
}
/* ----------------------------------------------------------------
@@ -2237,7 +2248,6 @@ ExecCrossPartitionUpdateForeignKey(ModifyTableContext *context,
* no relevant triggers.
*
* slot contains the new tuple value to be stored.
- * oldslot is the slot to store the old tuple.
* planSlot is the output of the ModifyTable's subplan; we use it
* to access values from other input tables (for RETURNING),
* row-ID junk columns, etc.
@@ -2248,7 +2258,7 @@ ExecCrossPartitionUpdateForeignKey(ModifyTableContext *context,
static TupleTableSlot *
ExecUpdate(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
ItemPointer tupleid, HeapTuple oldtuple, TupleTableSlot *slot,
- TupleTableSlot *oldslot, bool canSetTag, bool locked)
+ bool canSetTag)
{
EState *estate = context->estate;
Relation resultRelationDesc = resultRelInfo->ri_RelationDesc;
@@ -2301,16 +2311,6 @@ ExecUpdate(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
}
else
{
- int options = TABLE_MODIFY_WAIT | TABLE_MODIFY_FETCH_OLD_TUPLE;
-
- /*
- * Specify that we need to lock and fetch the last tuple version for
- * EPQ on appropriate transaction isolation levels if the tuple isn't
- * locked already.
- */
- if (!locked && !IsolationUsesXactSnapshot())
- options |= TABLE_MODIFY_LOCK_UPDATED;
-
/*
* If we generate a new candidate tuple after EvalPlanQual testing, we
* must loop back here to try again. (We don't need to redo triggers,
@@ -2320,7 +2320,7 @@ ExecUpdate(ModifyTableContext *context, ResultRelInfo *resultRelInfo,
*/
redo_act:
result = ExecUpdateAct(context, resultRelInfo, tupleid, oldtuple, slot,
- canSetTag, options, oldslot, &updateCxt);
+ canSetTag, &updateCxt);
/*
* If ExecUpdateAct reports that a cross-partition update was done,
@@ -2371,32 +2371,88 @@ redo_act:
case TM_Updated:
{
+ TupleTableSlot *inputslot;
TupleTableSlot *epqslot;
+ TupleTableSlot *oldSlot;
if (IsolationUsesXactSnapshot())
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
- /* Shouldn't get there if the tuple was previously locked */
- Assert(!locked);
-
/*
- * We need to do EPQ. The latest tuple is already found
- * and locked as a result of TABLE_MODIFY_LOCK_UPDATED.
+ * Already know that we're going to need to do EPQ, so
+ * fetch tuple directly into the right slot.
*/
- Assert(context->tmfd.traversed);
- epqslot = EvalPlanQual(context->epqstate,
- resultRelationDesc,
- resultRelInfo->ri_RangeTableIndex,
- oldslot);
- if (TupIsNull(epqslot))
- /* Tuple not passing quals anymore, exiting... */
- return NULL;
- slot = ExecGetUpdateNewTuple(resultRelInfo,
- epqslot,
- oldslot);
- goto redo_act;
+ inputslot = EvalPlanQualSlot(context->epqstate, resultRelationDesc,
+ resultRelInfo->ri_RangeTableIndex);
+
+ result = table_tuple_lock(resultRelationDesc, tupleid,
+ estate->es_snapshot,
+ inputslot, estate->es_output_cid,
+ updateCxt.lockmode, LockWaitBlock,
+ TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
+ &context->tmfd);
+
+ switch (result)
+ {
+ case TM_Ok:
+ Assert(context->tmfd.traversed);
+
+ epqslot = EvalPlanQual(context->epqstate,
+ resultRelationDesc,
+ resultRelInfo->ri_RangeTableIndex,
+ inputslot);
+ if (TupIsNull(epqslot))
+ /* Tuple not passing quals anymore, exiting... */
+ return NULL;
+
+ /* Make sure ri_oldTupleSlot is initialized. */
+ if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
+ ExecInitUpdateProjection(context->mtstate,
+ resultRelInfo);
+
+ /* Fetch the most recent version of old tuple. */
+ oldSlot = resultRelInfo->ri_oldTupleSlot;
+ if (!table_tuple_fetch_row_version(resultRelationDesc,
+ tupleid,
+ SnapshotAny,
+ oldSlot))
+ elog(ERROR, "failed to fetch tuple being updated");
+ slot = ExecGetUpdateNewTuple(resultRelInfo,
+ epqslot, oldSlot);
+ goto redo_act;
+
+ case TM_Deleted:
+ /* tuple already deleted; nothing to do */
+ return NULL;
+
+ case TM_SelfModified:
+
+ /*
+ * This can be reached when following an update
+ * chain from a tuple updated by another session,
+ * reaching a tuple that was already updated in
+ * this transaction. If previously modified by
+ * this command, ignore the redundant update,
+ * otherwise error out.
+ *
+ * See also TM_SelfModified response to
+ * table_tuple_update() above.
+ */
+ if (context->tmfd.cmax != estate->es_output_cid)
+ ereport(ERROR,
+ (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
+ errmsg("tuple to be updated was already modified by an operation triggered by the current command"),
+ errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
+ return NULL;
+
+ default:
+ /* see table_tuple_lock call in ExecDelete() */
+ elog(ERROR, "unexpected table_tuple_lock status: %u",
+ result);
+ return NULL;
+ }
}
break;
@@ -2420,7 +2476,7 @@ redo_act:
(estate->es_processed)++;
ExecUpdateEpilogue(context, &updateCxt, resultRelInfo, tupleid, oldtuple,
- slot, oldslot);
+ slot);
/* Process RETURNING if present */
if (resultRelInfo->ri_projectReturning)
@@ -2638,8 +2694,7 @@ ExecOnConflictUpdate(ModifyTableContext *context,
*returning = ExecUpdate(context, resultRelInfo,
conflictTid, NULL,
resultRelInfo->ri_onConflict->oc_ProjSlot,
- existing,
- canSetTag, true);
+ canSetTag);
/*
* Clear out existing tuple, as there might not be another conflict among
@@ -2918,7 +2973,6 @@ lmerge_matched:
{
result = ExecUpdateAct(context, resultRelInfo, tupleid,
NULL, newslot, canSetTag,
- TABLE_MODIFY_WAIT, NULL,
&updateCxt);
/*
@@ -2940,8 +2994,7 @@ lmerge_matched:
if (result == TM_Ok)
{
ExecUpdateEpilogue(context, &updateCxt, resultRelInfo,
- tupleid, NULL, newslot,
- resultRelInfo->ri_oldTupleSlot);
+ tupleid, NULL, newslot);
mtstate->mt_merge_updated += 1;
}
break;
@@ -2967,12 +3020,12 @@ lmerge_matched:
}
else
result = ExecDeleteAct(context, resultRelInfo, tupleid,
- false, TABLE_MODIFY_WAIT, NULL);
+ false);
if (result == TM_Ok)
{
ExecDeleteEpilogue(context, resultRelInfo, tupleid, NULL,
- resultRelInfo->ri_oldTupleSlot, false);
+ false);
mtstate->mt_merge_deleted += 1;
}
break;
@@ -4037,18 +4090,12 @@ ExecModifyTable(PlanState *pstate)
/* Now apply the update. */
slot = ExecUpdate(&context, resultRelInfo, tupleid, oldtuple,
- slot, resultRelInfo->ri_oldTupleSlot,
- node->canSetTag, false);
+ slot, node->canSetTag);
break;
case CMD_DELETE:
- /* Initialize slot for DELETE to fetch the old tuple */
- if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
- ExecInitDeleteTupleSlot(node, resultRelInfo);
-
slot = ExecDelete(&context, resultRelInfo, tupleid, oldtuple,
- resultRelInfo->ri_oldTupleSlot, true, false,
- node->canSetTag, NULL, NULL, NULL);
+ true, false, node->canSetTag, NULL, NULL, NULL);
break;
case CMD_MERGE:
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index 3abe226bd5d..735662dc9df 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -322,22 +322,19 @@ extern void heap_multi_insert(Relation relation, struct TupleTableSlot **slots,
int ntuples, CommandId cid, int options,
BulkInsertState bistate);
extern TM_Result heap_delete(Relation relation, ItemPointer tid,
- CommandId cid, Snapshot crosscheck, int options,
- struct TM_FailureData *tmfd, bool changingPart,
- TupleTableSlot *oldSlot);
+ CommandId cid, Snapshot crosscheck, bool wait,
+ struct TM_FailureData *tmfd, bool changingPart);
extern void heap_finish_speculative(Relation relation, ItemPointer tid);
extern void heap_abort_speculative(Relation relation, ItemPointer tid);
extern TM_Result heap_update(Relation relation, ItemPointer otid,
HeapTuple newtup,
- CommandId cid, Snapshot crosscheck, int options,
+ CommandId cid, Snapshot crosscheck, bool wait,
struct TM_FailureData *tmfd, LockTupleMode *lockmode,
- TU_UpdateIndexes *update_indexes,
- TupleTableSlot *oldSlot);
-extern TM_Result heap_lock_tuple(Relation relation, ItemPointer tid,
- TupleTableSlot *slot,
- CommandId cid, LockTupleMode mode,
- LockWaitPolicy wait_policy, bool follow_updates,
- struct TM_FailureData *tmfd);
+ TU_UpdateIndexes *update_indexes);
+extern TM_Result heap_lock_tuple(Relation relation, HeapTuple tuple,
+ CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy,
+ bool follow_updates,
+ Buffer *buffer, struct TM_FailureData *tmfd);
extern void heap_inplace_update(Relation relation, HeapTuple tuple);
extern bool heap_prepare_freeze_tuple(HeapTupleHeader tuple,
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 00deb36f5a4..6ef7714d2bc 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -267,15 +267,6 @@ typedef struct TM_IndexDeleteOp
/* Follow update chain and lock latest version of tuple */
#define TUPLE_LOCK_FLAG_FIND_LAST_VERSION (1 << 1)
-/*
- * "options" flag bits for table_tuple_update and table_tuple_delete,
- * Wait for any conflicting update to commit/abort */
-#define TABLE_MODIFY_WAIT 0x0001
-/* Fetch the existing tuple into a dedicated slot */
-#define TABLE_MODIFY_FETCH_OLD_TUPLE 0x0002
-/* On concurrent update, follow the update chain and lock latest version of tuple */
-#define TABLE_MODIFY_LOCK_UPDATED 0x0004
-
/* Typedef for callback function for table_index_build_scan */
typedef void (*IndexBuildCallback) (Relation index,
@@ -545,10 +536,9 @@ typedef struct TableAmRoutine
CommandId cid,
Snapshot snapshot,
Snapshot crosscheck,
- int options,
+ bool wait,
TM_FailureData *tmfd,
- bool changingPart,
- TupleTableSlot *oldSlot);
+ bool changingPart);
/* see table_tuple_update() for reference about parameters */
TM_Result (*tuple_update) (Relation rel,
@@ -557,11 +547,10 @@ typedef struct TableAmRoutine
CommandId cid,
Snapshot snapshot,
Snapshot crosscheck,
- int options,
+ bool wait,
TM_FailureData *tmfd,
LockTupleMode *lockmode,
- TU_UpdateIndexes *update_indexes,
- TupleTableSlot *oldSlot);
+ TU_UpdateIndexes *update_indexes);
/* see table_tuple_lock() for reference about parameters */
TM_Result (*tuple_lock) (Relation rel,
@@ -1456,7 +1445,7 @@ table_multi_insert(Relation rel, TupleTableSlot **slots, int nslots,
}
/*
- * Delete a tuple (and optionally lock the last tuple version).
+ * Delete a tuple.
*
* NB: do not call this directly unless prepared to deal with
* concurrent-update conditions. Use simple_table_tuple_delete instead.
@@ -1467,21 +1456,11 @@ table_multi_insert(Relation rel, TupleTableSlot **slots, int nslots,
* cid - delete command ID (used for visibility test, and stored into
* cmax if successful)
* crosscheck - if not InvalidSnapshot, also check tuple against this
- * options:
- * If TABLE_MODIFY_WAIT, wait for any conflicting update to commit/abort.
- * If TABLE_MODIFY_FETCH_OLD_TUPLE option is given, the existing tuple is
- * fetched into oldSlot when the update is successful.
- * If TABLE_MODIFY_LOCK_UPDATED option is given and the tuple is
- * concurrently updated, then the last tuple version is locked and fetched
- * into oldSlot.
- *
+ * wait - true if should wait for any conflicting update to commit/abort
* Output parameters:
* tmfd - filled in failure cases (see below)
* changingPart - true iff the tuple is being moved to another partition
* table due to an update of the partition key. Otherwise, false.
- * oldSlot - slot to save the deleted or locked tuple. Can be NULL if none of
- * TABLE_MODIFY_FETCH_OLD_TUPLE or TABLE_MODIFY_LOCK_UPDATED options
- * is specified.
*
* Normal, successful return value is TM_Ok, which means we did actually
* delete it. Failure return codes are TM_SelfModified, TM_Updated, and
@@ -1493,18 +1472,16 @@ table_multi_insert(Relation rel, TupleTableSlot **slots, int nslots,
*/
static inline TM_Result
table_tuple_delete(Relation rel, ItemPointer tid, CommandId cid,
- Snapshot snapshot, Snapshot crosscheck, int options,
- TM_FailureData *tmfd, bool changingPart,
- TupleTableSlot *oldSlot)
+ Snapshot snapshot, Snapshot crosscheck, bool wait,
+ TM_FailureData *tmfd, bool changingPart)
{
return rel->rd_tableam->tuple_delete(rel, tid, cid,
snapshot, crosscheck,
- options, tmfd, changingPart,
- oldSlot);
+ wait, tmfd, changingPart);
}
/*
- * Update a tuple (and optionally lock the last tuple version).
+ * Update a tuple.
*
* NB: do not call this directly unless you are prepared to deal with
* concurrent-update conditions. Use simple_table_tuple_update instead.
@@ -1516,23 +1493,13 @@ table_tuple_delete(Relation rel, ItemPointer tid, CommandId cid,
* cid - update command ID (used for visibility test, and stored into
* cmax/cmin if successful)
* crosscheck - if not InvalidSnapshot, also check old tuple against this
- * options:
- * If TABLE_MODIFY_WAIT, wait for any conflicting update to commit/abort.
- * If TABLE_MODIFY_FETCH_OLD_TUPLE option is given, the existing tuple is
- * fetched into oldSlot when the update is successful.
- * If TABLE_MODIFY_LOCK_UPDATED option is given and the tuple is
- * concurrently updated, then the last tuple version is locked and fetched
- * into oldSlot.
- *
+ * wait - true if should wait for any conflicting update to commit/abort
* Output parameters:
* tmfd - filled in failure cases (see below)
* lockmode - filled with lock mode acquired on tuple
* update_indexes - in success cases this is set to true if new index entries
* are required for this tuple
- * oldSlot - slot to save the deleted or locked tuple. Can be NULL if none of
- * TABLE_MODIFY_FETCH_OLD_TUPLE or TABLE_MODIFY_LOCK_UPDATED options
- * is specified.
-
+ *
* Normal, successful return value is TM_Ok, which means we did actually
* update it. Failure return codes are TM_SelfModified, TM_Updated, and
* TM_BeingModified (the last only possible if wait == false).
@@ -1550,15 +1517,13 @@ table_tuple_delete(Relation rel, ItemPointer tid, CommandId cid,
static inline TM_Result
table_tuple_update(Relation rel, ItemPointer otid, TupleTableSlot *slot,
CommandId cid, Snapshot snapshot, Snapshot crosscheck,
- int options, TM_FailureData *tmfd, LockTupleMode *lockmode,
- TU_UpdateIndexes *update_indexes,
- TupleTableSlot *oldSlot)
+ bool wait, TM_FailureData *tmfd, LockTupleMode *lockmode,
+ TU_UpdateIndexes *update_indexes)
{
return rel->rd_tableam->tuple_update(rel, otid, slot,
cid, snapshot, crosscheck,
- options, tmfd,
- lockmode, update_indexes,
- oldSlot);
+ wait, tmfd,
+ lockmode, update_indexes);
}
/*
@@ -2079,12 +2044,10 @@ table_scan_sample_next_tuple(TableScanDesc scan,
extern void simple_table_tuple_insert(Relation rel, TupleTableSlot *slot);
extern void simple_table_tuple_delete(Relation rel, ItemPointer tid,
- Snapshot snapshot,
- TupleTableSlot *oldSlot);
+ Snapshot snapshot);
extern void simple_table_tuple_update(Relation rel, ItemPointer otid,
TupleTableSlot *slot, Snapshot snapshot,
- TU_UpdateIndexes *update_indexes,
- TupleTableSlot *oldSlot);
+ TU_UpdateIndexes *update_indexes);
/* ----------------------------------------------------------------------------
diff --git a/src/include/commands/trigger.h b/src/include/commands/trigger.h
index cb968d03ecd..8a5a9fe6422 100644
--- a/src/include/commands/trigger.h
+++ b/src/include/commands/trigger.h
@@ -216,8 +216,8 @@ extern bool ExecBRDeleteTriggers(EState *estate,
TM_FailureData *tmfd);
extern void ExecARDeleteTriggers(EState *estate,
ResultRelInfo *relinfo,
+ ItemPointer tupleid,
HeapTuple fdw_trigtuple,
- TupleTableSlot *slot,
TransitionCaptureState *transition_capture,
bool is_crosspart_update);
extern bool ExecIRDeleteTriggers(EState *estate,
@@ -240,8 +240,8 @@ extern void ExecARUpdateTriggers(EState *estate,
ResultRelInfo *relinfo,
ResultRelInfo *src_partinfo,
ResultRelInfo *dst_partinfo,
+ ItemPointer tupleid,
HeapTuple fdw_trigtuple,
- TupleTableSlot *oldslot,
TupleTableSlot *newslot,
List *recheckIndexes,
TransitionCaptureState *transition_capture,
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-21 13:10:40 +0000