heapam.c File Reference
#include "postgres.h"#include "access/heapam.h"#include "access/heaptoast.h"#include "access/hio.h"#include "access/multixact.h"#include "access/subtrans.h"#include "access/syncscan.h"#include "access/valid.h"#include "access/visibilitymap.h"#include "access/xloginsert.h"#include "catalog/pg_database.h"#include "catalog/pg_database_d.h"#include "commands/vacuum.h"#include "pgstat.h"#include "port/pg_bitutils.h"#include "storage/lmgr.h"#include "storage/predicate.h"#include "storage/procarray.h"#include "utils/datum.h"#include "utils/injection_point.h"#include "utils/inval.h"#include "utils/spccache.h"#include "utils/syscache.h"
Include dependency graph for heapam.c:
Go to the source code of this file.
Data Structures | |
| struct | IndexDeleteCounts |
Macros | |
| #define | LOCKMODE_from_mxstatus(status) (tupleLockExtraInfo[TUPLOCK_from_mxstatus((status))].hwlock) |
| #define | LockTupleTuplock(rel, tup, mode) LockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock) |
| #define | UnlockTupleTuplock(rel, tup, mode) UnlockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock) |
| #define | ConditionalLockTupleTuplock(rel, tup, mode, log) ConditionalLockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock, (log)) |
| #define | BOTTOMUP_MAX_NBLOCKS 6 |
| #define | BOTTOMUP_TOLERANCE_NBLOCKS 3 |
| #define | TUPLOCK_from_mxstatus(status) (MultiXactStatusLock[(status)]) |
| #define | FRM_NOOP 0x0001 |
| #define | FRM_INVALIDATE_XMAX 0x0002 |
| #define | FRM_RETURN_IS_XID 0x0004 |
| #define | FRM_RETURN_IS_MULTI 0x0008 |
| #define | FRM_MARK_COMMITTED 0x0010 |
Typedefs | |
| typedef struct IndexDeleteCounts | IndexDeleteCounts |
Variables | |
| struct { | |
| LOCKMODE hwlock | |
| int lockstatus | |
| int updstatus | |
| } | tupleLockExtraInfo [MaxLockTupleMode+1] |
| static const int | MultiXactStatusLock [MaxMultiXactStatus+1] |
Macro Definition Documentation
◆ BOTTOMUP_MAX_NBLOCKS
◆ BOTTOMUP_TOLERANCE_NBLOCKS
◆ ConditionalLockTupleTuplock
| #define ConditionalLockTupleTuplock | ( | rel, | |
| tup, | |||
| mode, | |||
| log | |||
| ) | ConditionalLockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock, (log)) |
◆ FRM_INVALIDATE_XMAX
◆ FRM_MARK_COMMITTED
◆ FRM_NOOP
◆ FRM_RETURN_IS_MULTI
◆ FRM_RETURN_IS_XID
◆ LOCKMODE_from_mxstatus
| #define LOCKMODE_from_mxstatus | ( | status | ) | (tupleLockExtraInfo[TUPLOCK_from_mxstatus((status))].hwlock) |
◆ LockTupleTuplock
| #define LockTupleTuplock | ( | rel, | |
| tup, | |||
| mode | |||
| ) | LockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock) |
◆ TUPLOCK_from_mxstatus
| #define TUPLOCK_from_mxstatus | ( | status | ) | (MultiXactStatusLock[(status)]) |
◆ UnlockTupleTuplock
| #define UnlockTupleTuplock | ( | rel, | |
| tup, | |||
| mode | |||
| ) | UnlockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock) |
Typedef Documentation
◆ IndexDeleteCounts
| typedef struct IndexDeleteCounts IndexDeleteCounts |
Function Documentation
◆ AssertHasSnapshotForToast()
|
inlinestatic |
Definition at line 220 of file heapam.c.
221{
222#ifdef USE_ASSERT_CHECKING
223
224 /* bootstrap mode in particular breaks this rule */
226 return;
227
228 /* if the relation doesn't have a TOAST table, we are good */
230 return;
231
233
234#endif /* USE_ASSERT_CHECKING */
235}
Assert(PointerIsAligned(start, uint64))
References Assert(), HaveRegisteredOrActiveSnapshot(), IsNormalProcessingMode, OidIsValid, and RelationData::rd_rel.
Referenced by heap_delete(), heap_insert(), heap_multi_insert(), and heap_update().
◆ bitmapheap_stream_read_next()
|
static |
Definition at line 312 of file heapam.c.
314{
315 TBMIterateResult *tbmres = per_buffer_data;
319
320 for (;;)
321 {
322 CHECK_FOR_INTERRUPTS();
323
324 /* no more entries in the bitmap */
327
328 /*
329 * Ignore any claimed entries past what we think is the end of the
330 * relation. It may have been extended after the start of our scan (we
331 * only hold an AccessShareLock, and it could be inserts from this
332 * backend). We don't take this optimization in SERIALIZABLE
333 * isolation though, as we need to examine all invisible tuples
334 * reachable by the index.
335 */
338 continue;
339
341 }
342
343 /* not reachable */
345}
Definition: heapam.h:105
Definition: heapam.h:57
Definition: tidbitmap.h:62
Definition: relscan.h:34
union TableScanDescData::@50 st
bool tbm_iterate(TBMIterator *iterator, TBMIterateResult *tbmres)
Definition: tidbitmap.c:1614
References Assert(), TBMIterateResult::blockno, CHECK_FOR_INTERRUPTS, InvalidBlockNumber, IsolationIsSerializable, HeapScanDescData::rs_base, HeapScanDescData::rs_nblocks, TableScanDescData::rs_tbmiterator, TableScanDescData::st, and tbm_iterate().
Referenced by heap_beginscan().
◆ bottomup_nblocksfavorable()
|
static |
Definition at line 8585 of file heapam.c.
8587{
8588 int64 lastblock = -1;
8589 int nblocksfavorable = 0;
8590
8591 Assert(nblockgroups >= 1);
8593
8594 /*
8595 * We tolerate heap blocks that will be accessed only slightly out of
8596 * physical order. Small blips occur when a pair of almost-contiguous
8597 * blocks happen to fall into different buckets (perhaps due only to a
8598 * small difference in npromisingtids that the bucketing scheme didn't
8599 * quite manage to ignore). We effectively ignore these blips by applying
8600 * a small tolerance. The precise tolerance we use is a little arbitrary,
8601 * but it works well enough in practice.
8602 */
8604 {
8608
8609 if (lastblock != -1 &&
8612 break;
8613
8614 nblocksfavorable++;
8615 lastblock = block;
8616 }
8617
8618 /* Always indicate that there is at least 1 favorable block */
8619 Assert(nblocksfavorable >= 1);
8620
8621 return nblocksfavorable;
8622}
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
Definition: heapam.c:192
Definition: tableam.h:211
References Assert(), b, BOTTOMUP_MAX_NBLOCKS, BOTTOMUP_TOLERANCE_NBLOCKS, IndexDeleteCounts::ifirsttid, ItemPointerGetBlockNumber(), and TM_IndexDelete::tid.
Referenced by bottomup_sort_and_shrink().
◆ bottomup_sort_and_shrink()
|
static |
Definition at line 8701 of file heapam.c.
8702{
8703 IndexDeleteCounts *blockgroups;
8704 TM_IndexDelete *reordereddeltids;
8706 int nblockgroups = 0;
8707 int ncopied = 0;
8708 int nblocksfavorable = 0;
8709
8712
8713 /* Calculate per-heap-block count of TIDs */
8716 {
8721
8723 {
8724 /* New block group */
8725 nblockgroups++;
8726
8728 !BlockNumberIsValid(curblock));
8729
8730 curblock = ItemPointerGetBlockNumber(htid);
8732 blockgroups[nblockgroups - 1].ntids = 1;
8733 blockgroups[nblockgroups - 1].npromisingtids = 0;
8734 }
8735 else
8736 {
8737 blockgroups[nblockgroups - 1].ntids++;
8738 }
8739
8740 if (promising)
8741 blockgroups[nblockgroups - 1].npromisingtids++;
8742 }
8743
8744 /*
8745 * We're about ready to sort block groups to determine the optimal order
8746 * for visiting heap blocks. But before we do, round the number of
8747 * promising tuples for each block group up to the next power-of-two,
8748 * unless it is very low (less than 4), in which case we round up to 4.
8749 * npromisingtids is far too noisy to trust when choosing between a pair
8750 * of block groups that both have very low values.
8751 *
8752 * This scheme divides heap blocks/block groups into buckets. Each bucket
8753 * contains blocks that have _approximately_ the same number of promising
8754 * TIDs as each other. The goal is to ignore relatively small differences
8755 * in the total number of promising entries, so that the whole process can
8756 * give a little weight to heapam factors (like heap block locality)
8757 * instead. This isn't a trade-off, really -- we have nothing to lose. It
8758 * would be foolish to interpret small differences in npromisingtids
8759 * values as anything more than noise.
8760 *
8761 * We tiebreak on nhtids when sorting block group subsets that have the
8762 * same npromisingtids, but this has the same issues as npromisingtids,
8763 * and so nhtids is subject to the same power-of-two bucketing scheme. The
8764 * only reason that we don't fix nhtids in the same way here too is that
8765 * we'll need accurate nhtids values after the sort. We handle nhtids
8766 * bucketization dynamically instead (in the sort comparator).
8767 *
8768 * See bottomup_nblocksfavorable() for a full explanation of when and how
8769 * heap locality/favorable blocks can significantly influence when and how
8770 * heap blocks are accessed.
8771 */
8773 {
8775
8776 /* Better off falling back on nhtids with low npromisingtids */
8778 group->npromisingtids = 4;
8779 else
8780 group->npromisingtids =
8782 }
8783
8784 /* Sort groups and rearrange caller's deltids array */
8786 bottomup_sort_and_shrink_cmp);
8788
8790 /* Determine number of favorable blocks at the start of final deltids */
8791 nblocksfavorable = bottomup_nblocksfavorable(blockgroups, nblockgroups,
8792 delstate->deltids);
8793
8795 {
8798
8799 memcpy(reordereddeltids + ncopied, firstdtid,
8801 ncopied += group->ntids;
8802 }
8803
8804 /* Copy final grouped and sorted TIDs back into start of caller's array */
8805 memcpy(delstate->deltids, reordereddeltids,
8807 delstate->ndeltids = ncopied;
8808
8809 pfree(reordereddeltids);
8810 pfree(blockgroups);
8811
8812 return nblocksfavorable;
8813}
static int bottomup_nblocksfavorable(IndexDeleteCounts *blockgroups, int nblockgroups, TM_IndexDelete *deltids)
Definition: heapam.c:8585
static int bottomup_sort_and_shrink_cmp(const void *arg1, const void *arg2)
Definition: heapam.c:8628
Definition: itemptr.h:37
Definition: tableam.h:217
References Assert(), b, BlockNumberIsValid(), TM_IndexDeleteOp::bottomup, BOTTOMUP_MAX_NBLOCKS, bottomup_nblocksfavorable(), bottomup_sort_and_shrink_cmp(), TM_IndexDeleteOp::deltids, i, TM_IndexDelete::id, IndexDeleteCounts::ifirsttid, InvalidBlockNumber, ItemPointerGetBlockNumber(), Min, TM_IndexDeleteOp::ndeltids, IndexDeleteCounts::npromisingtids, IndexDeleteCounts::ntids, palloc(), pfree(), pg_nextpower2_32(), TM_IndexStatus::promising, qsort, TM_IndexDeleteOp::status, and TM_IndexDelete::tid.
Referenced by heap_index_delete_tuples().
◆ bottomup_sort_and_shrink_cmp()
|
static |
Definition at line 8628 of file heapam.c.
8629{
8632
8633 /*
8634 * Most significant field is npromisingtids (which we invert the order of
8635 * so as to sort in desc order).
8636 *
8637 * Caller should have already normalized npromisingtids fields into
8638 * power-of-two values (buckets).
8639 */
8641 return -1;
8643 return 1;
8644
8645 /*
8646 * Tiebreak: desc ntids sort order.
8647 *
8648 * We cannot expect power-of-two values for ntids fields. We should
8649 * behave as if they were already rounded up for us instead.
8650 */
8652 {
8655
8656 if (ntids1 > ntids2)
8657 return -1;
8658 if (ntids1 < ntids2)
8659 return 1;
8660 }
8661
8662 /*
8663 * Tiebreak: asc offset-into-deltids-for-block (offset to first TID for
8664 * block in deltids array) order.
8665 *
8666 * This is equivalent to sorting in ascending heap block number order
8667 * (among otherwise equal subsets of the array). This approach allows us
8668 * to avoid accessing the out-of-line TID. (We rely on the assumption
8669 * that the deltids array was sorted in ascending heap TID order when
8670 * these offsets to the first TID from each heap block group were formed.)
8671 */
8673 return 1;
8675 return -1;
8676
8677 pg_unreachable();
8678
8679 return 0;
8680}
References IndexDeleteCounts::ifirsttid, IndexDeleteCounts::npromisingtids, IndexDeleteCounts::ntids, pg_nextpower2_32(), and pg_unreachable.
Referenced by bottomup_sort_and_shrink().
◆ compute_infobits()
Definition at line 2759 of file heapam.c.
2760{
2761 return
2765 /* note we ignore HEAP_XMAX_SHR_LOCK here */
2767 ((infomask2 & HEAP_KEYS_UPDATED) != 0 ?
2768 XLHL_KEYS_UPDATED : 0);
2769}
References HEAP_KEYS_UPDATED, HEAP_XMAX_EXCL_LOCK, HEAP_XMAX_IS_MULTI, HEAP_XMAX_KEYSHR_LOCK, HEAP_XMAX_LOCK_ONLY, XLHL_KEYS_UPDATED, XLHL_XMAX_EXCL_LOCK, XLHL_XMAX_IS_MULTI, XLHL_XMAX_KEYSHR_LOCK, and XLHL_XMAX_LOCK_ONLY.
Referenced by heap_abort_speculative(), heap_delete(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_update(), and log_heap_update().
◆ compute_new_xmax_infomask()
|
static |
Definition at line 5352 of file heapam.c.
5357{
5358 TransactionId new_xmax;
5359 uint16 new_infomask,
5360 new_infomask2;
5361
5363
5364l5:
5365 new_infomask = 0;
5366 new_infomask2 = 0;
5368 {
5369 /*
5370 * No previous locker; we just insert our own TransactionId.
5371 *
5372 * Note that it's critical that this case be the first one checked,
5373 * because there are several blocks below that come back to this one
5374 * to implement certain optimizations; old_infomask might contain
5375 * other dirty bits in those cases, but we don't really care.
5376 */
5377 if (is_update)
5378 {
5379 new_xmax = add_to_xmax;
5381 new_infomask2 |= HEAP_KEYS_UPDATED;
5382 }
5383 else
5384 {
5385 new_infomask |= HEAP_XMAX_LOCK_ONLY;
5387 {
5389 new_xmax = add_to_xmax;
5390 new_infomask |= HEAP_XMAX_KEYSHR_LOCK;
5391 break;
5393 new_xmax = add_to_xmax;
5394 new_infomask |= HEAP_XMAX_SHR_LOCK;
5395 break;
5397 new_xmax = add_to_xmax;
5398 new_infomask |= HEAP_XMAX_EXCL_LOCK;
5399 break;
5401 new_xmax = add_to_xmax;
5402 new_infomask |= HEAP_XMAX_EXCL_LOCK;
5403 new_infomask2 |= HEAP_KEYS_UPDATED;
5404 break;
5405 default:
5408 }
5409 }
5410 }
5412 {
5413 MultiXactStatus new_status;
5414
5415 /*
5416 * Currently we don't allow XMAX_COMMITTED to be set for multis, so
5417 * cross-check.
5418 */
5420
5421 /*
5422 * A multixact together with LOCK_ONLY set but neither lock bit set
5423 * (i.e. a pg_upgraded share locked tuple) cannot possibly be running
5424 * anymore. This check is critical for databases upgraded by
5425 * pg_upgrade; both MultiXactIdIsRunning and MultiXactIdExpand assume
5426 * that such multis are never passed.
5427 */
5429 {
5430 old_infomask &= ~HEAP_XMAX_IS_MULTI;
5431 old_infomask |= HEAP_XMAX_INVALID;
5432 goto l5;
5433 }
5434
5435 /*
5436 * If the XMAX is already a MultiXactId, then we need to expand it to
5437 * include add_to_xmax; but if all the members were lockers and are
5438 * all gone, we can do away with the IS_MULTI bit and just set
5439 * add_to_xmax as the only locker/updater. If all lockers are gone
5440 * and we have an updater that aborted, we can also do without a
5441 * multi.
5442 *
5443 * The cost of doing GetMultiXactIdMembers would be paid by
5444 * MultiXactIdExpand if we weren't to do this, so this check is not
5445 * incurring extra work anyhow.
5446 */
5448 {
5451 old_infomask)))
5452 {
5453 /*
5454 * Reset these bits and restart; otherwise fall through to
5455 * create a new multi below.
5456 */
5457 old_infomask &= ~HEAP_XMAX_IS_MULTI;
5458 old_infomask |= HEAP_XMAX_INVALID;
5459 goto l5;
5460 }
5461 }
5462
5464
5466 new_status);
5467 GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5468 }
5470 {
5471 /*
5472 * It's a committed update, so we need to preserve him as updater of
5473 * the tuple.
5474 */
5475 MultiXactStatus status;
5476 MultiXactStatus new_status;
5477
5479 status = MultiXactStatusUpdate;
5480 else
5481 status = MultiXactStatusNoKeyUpdate;
5482
5484
5485 /*
5486 * since it's not running, it's obviously impossible for the old
5487 * updater to be identical to the current one, so we need not check
5488 * for that case as we do in the block above.
5489 */
5490 new_xmax = MultiXactIdCreate(xmax, status, add_to_xmax, new_status);
5491 GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5492 }
5494 {
5495 /*
5496 * If the XMAX is a valid, in-progress TransactionId, then we need to
5497 * create a new MultiXactId that includes both the old locker or
5498 * updater and our own TransactionId.
5499 */
5500 MultiXactStatus new_status;
5501 MultiXactStatus old_status;
5502 LockTupleMode old_mode;
5503
5505 {
5507 old_status = MultiXactStatusForKeyShare;
5509 old_status = MultiXactStatusForShare;
5511 {
5513 old_status = MultiXactStatusForUpdate;
5514 else
5515 old_status = MultiXactStatusForNoKeyUpdate;
5516 }
5517 else
5518 {
5519 /*
5520 * LOCK_ONLY can be present alone only when a page has been
5521 * upgraded by pg_upgrade. But in that case,
5522 * TransactionIdIsInProgress() should have returned false. We
5523 * assume it's no longer locked in this case.
5524 */
5526 old_infomask |= HEAP_XMAX_INVALID;
5527 old_infomask &= ~HEAP_XMAX_LOCK_ONLY;
5528 goto l5;
5529 }
5530 }
5531 else
5532 {
5533 /* it's an update, but which kind? */
5535 old_status = MultiXactStatusUpdate;
5536 else
5537 old_status = MultiXactStatusNoKeyUpdate;
5538 }
5539
5540 old_mode = TUPLOCK_from_mxstatus(old_status);
5541
5542 /*
5543 * If the lock to be acquired is for the same TransactionId as the
5544 * existing lock, there's an optimization possible: consider only the
5545 * strongest of both locks as the only one present, and restart.
5546 */
5547 if (xmax == add_to_xmax)
5548 {
5549 /*
5550 * Note that it's not possible for the original tuple to be
5551 * updated: we wouldn't be here because the tuple would have been
5552 * invisible and we wouldn't try to update it. As a subtlety,
5553 * this code can also run when traversing an update chain to lock
5554 * future versions of a tuple. But we wouldn't be here either,
5555 * because the add_to_xmax would be different from the original
5556 * updater.
5557 */
5559
5560 /* acquire the strongest of both */
5562 mode = old_mode;
5563 /* mustn't touch is_update */
5564
5565 old_infomask |= HEAP_XMAX_INVALID;
5566 goto l5;
5567 }
5568
5569 /* otherwise, just fall back to creating a new multixact */
5571 new_xmax = MultiXactIdCreate(xmax, old_status,
5572 add_to_xmax, new_status);
5573 GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5574 }
5576 TransactionIdDidCommit(xmax))
5577 {
5578 /*
5579 * It's a committed update, so we gotta preserve him as updater of the
5580 * tuple.
5581 */
5582 MultiXactStatus status;
5583 MultiXactStatus new_status;
5584
5586 status = MultiXactStatusUpdate;
5587 else
5588 status = MultiXactStatusNoKeyUpdate;
5589
5591
5592 /*
5593 * since it's not running, it's obviously impossible for the old
5594 * updater to be identical to the current one, so we need not check
5595 * for that case as we do in the block above.
5596 */
5597 new_xmax = MultiXactIdCreate(xmax, status, add_to_xmax, new_status);
5598 GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5599 }
5600 else
5601 {
5602 /*
5603 * Can get here iff the locking/updating transaction was running when
5604 * the infomask was extracted from the tuple, but finished before
5605 * TransactionIdIsInProgress got to run. Deal with it as if there was
5606 * no locker at all in the first place.
5607 */
5608 old_infomask |= HEAP_XMAX_INVALID;
5609 goto l5;
5610 }
5611
5612 *result_infomask = new_infomask;
5613 *result_infomask2 = new_infomask2;
5614 *result_xmax = new_xmax;
5615}
static void GetMultiXactIdHintBits(MultiXactId multi, uint16 *new_infomask, uint16 *new_infomask2)
Definition: heapam.c:7472
static TransactionId MultiXactIdGetUpdateXid(TransactionId xmax, uint16 t_infomask)
Definition: heapam.c:7553
static MultiXactStatus get_mxact_status_for_lock(LockTupleMode mode, bool is_update)
Definition: heapam.c:4558
static bool HEAP_XMAX_IS_SHR_LOCKED(uint16 infomask)
Definition: htup_details.h:263
static bool HEAP_XMAX_IS_LOCKED_ONLY(uint16 infomask)
Definition: htup_details.h:226
static bool HEAP_XMAX_IS_KEYSHR_LOCKED(uint16 infomask)
Definition: htup_details.h:275
static bool HEAP_XMAX_IS_EXCL_LOCKED(uint16 infomask)
Definition: htup_details.h:269
MultiXactId MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
Definition: multixact.c:471
bool MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly)
Definition: multixact.c:583
MultiXactId MultiXactIdCreate(TransactionId xid1, MultiXactStatus status1, TransactionId xid2, MultiXactStatus status2)
Definition: multixact.c:418
bool TransactionIdIsInProgress(TransactionId xid)
Definition: procarray.c:1402
bool TransactionIdDidCommit(TransactionId transactionId)
Definition: transam.c:126
bool TransactionIdIsCurrentTransactionId(TransactionId xid)
Definition: xact.c:942
References Assert(), elog, ERROR, get_mxact_status_for_lock(), GetMultiXactIdHintBits(), HEAP_KEYS_UPDATED, HEAP_LOCKED_UPGRADED(), HEAP_XMAX_COMMITTED, HEAP_XMAX_EXCL_LOCK, HEAP_XMAX_INVALID, HEAP_XMAX_IS_EXCL_LOCKED(), HEAP_XMAX_IS_KEYSHR_LOCKED(), HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMAX_IS_SHR_LOCKED(), HEAP_XMAX_KEYSHR_LOCK, HEAP_XMAX_LOCK_ONLY, HEAP_XMAX_SHR_LOCK, InvalidTransactionId, LockTupleExclusive, LockTupleKeyShare, LockTupleNoKeyExclusive, LockTupleShare, mode, MultiXactIdCreate(), MultiXactIdExpand(), MultiXactIdGetUpdateXid(), MultiXactIdIsRunning(), MultiXactStatusForKeyShare, MultiXactStatusForNoKeyUpdate, MultiXactStatusForShare, MultiXactStatusForUpdate, MultiXactStatusNoKeyUpdate, MultiXactStatusUpdate, TransactionIdDidCommit(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), TUPLOCK_from_mxstatus, and WARNING.
Referenced by heap_delete(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), and heap_update().
◆ ConditionalMultiXactIdWait()
|
static |
Definition at line 7821 of file heapam.c.
7824{
7827}
static bool Do_MultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, bool nowait, Relation rel, const ItemPointerData *ctid, XLTW_Oper oper, int *remaining, bool logLockFailure)
Definition: heapam.c:7721
References Do_MultiXactIdWait(), remaining, and XLTW_None.
Referenced by heap_lock_tuple().
◆ Do_MultiXactIdWait()
|
static |
Definition at line 7721 of file heapam.c.
7725{
7726 bool result = true;
7727 MultiXactMember *members;
7728 int nmembers;
7729 int remain = 0;
7730
7731 /* for pre-pg_upgrade tuples, no need to sleep at all */
7732 nmembers = HEAP_LOCKED_UPGRADED(infomask) ? -1 :
7734 HEAP_XMAX_IS_LOCKED_ONLY(infomask));
7735
7736 if (nmembers >= 0)
7737 {
7739
7741 {
7744
7746 {
7747 remain++;
7748 continue;
7749 }
7750
7752 LOCKMODE_from_mxstatus(status)))
7753 {
7755 remain++;
7756 continue;
7757 }
7758
7759 /*
7760 * This member conflicts with our multi, so we have to sleep (or
7761 * return failure, if asked to avoid waiting.)
7762 *
7763 * Note that we don't set up an error context callback ourselves,
7764 * but instead we pass the info down to XactLockTableWait. This
7765 * might seem a bit wasteful because the context is set up and
7766 * tore down for each member of the multixact, but in reality it
7767 * should be barely noticeable, and it avoids duplicate code.
7768 */
7769 if (nowait)
7770 {
7771 result = ConditionalXactLockTableWait(memxid, logLockFailure);
7772 if (!result)
7773 break;
7774 }
7775 else
7777 }
7778
7779 pfree(members);
7780 }
7781
7783 *remaining = remain;
7784
7785 return result;
7786}
bool ConditionalXactLockTableWait(TransactionId xid, bool logLockFailure)
Definition: lmgr.c:739
void XactLockTableWait(TransactionId xid, Relation rel, const ItemPointerData *ctid, XLTW_Oper oper)
Definition: lmgr.c:663
int GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members, bool from_pgupgrade, bool isLockOnly)
Definition: multixact.c:1334
Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
Definition: parse_oper.c:371
Definition: multixact.h:58
References ConditionalXactLockTableWait(), DoLockModesConflict(), GetMultiXactIdMembers(), HEAP_LOCKED_UPGRADED(), HEAP_XMAX_IS_LOCKED_ONLY(), i, LOCKMODE_from_mxstatus, oper(), pfree(), remaining, MultiXactMember::status, TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), XactLockTableWait(), and MultiXactMember::xid.
Referenced by ConditionalMultiXactIdWait(), and MultiXactIdWait().
◆ DoesMultiXactIdConflict()
|
static |
Definition at line 7621 of file heapam.c.
7623{
7624 int nmembers;
7625 MultiXactMember *members;
7626 bool result = false;
7628
7630 return false;
7631
7633 HEAP_XMAX_IS_LOCKED_ONLY(infomask));
7634 if (nmembers >= 0)
7635 {
7637
7639 {
7640 TransactionId memxid;
7641 LOCKMODE memlockmode;
7642
7643 if (result && (current_is_member == NULL || *current_is_member))
7644 break;
7645
7647
7648 /* ignore members from current xact (but track their presence) */
7651 {
7652 if (current_is_member != NULL)
7653 *current_is_member = true;
7654 continue;
7655 }
7656 else if (result)
7657 continue;
7658
7659 /* ignore members that don't conflict with the lock we want */
7661 continue;
7662
7664 {
7665 /* ignore aborted updaters */
7667 continue;
7668 }
7669 else
7670 {
7671 /* ignore lockers-only that are no longer in progress */
7673 continue;
7674 }
7675
7676 /*
7677 * Whatever remains are either live lockers that conflict with our
7678 * wanted lock, and updaters that are not aborted. Those conflict
7679 * with what we want. Set up to return true, but keep going to
7680 * look for the current transaction among the multixact members,
7681 * if needed.
7682 */
7683 result = true;
7684 }
7685 pfree(members);
7686 }
7687
7688 return result;
7689}
static const struct @15 tupleLockExtraInfo[MaxLockTupleMode+1]
bool TransactionIdDidAbort(TransactionId transactionId)
Definition: transam.c:188
References DoLockModesConflict(), GetMultiXactIdMembers(), HEAP_LOCKED_UPGRADED(), HEAP_XMAX_IS_LOCKED_ONLY(), i, ISUPDATE_from_mxstatus, LOCKMODE_from_mxstatus, pfree(), TransactionIdDidAbort(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), tupleLockExtraInfo, and MultiXactMember::xid.
Referenced by heap_delete(), heap_inplace_lock(), heap_lock_tuple(), and heap_update().
◆ ExtractReplicaIdentity()
|
static |
Definition at line 9167 of file heapam.c.
9169{
9172 Bitmapset *idattrs;
9173 HeapTuple key_tuple;
9176
9177 *copy = false;
9178
9180 return NULL;
9181
9182 if (replident == REPLICA_IDENTITY_NOTHING)
9183 return NULL;
9184
9185 if (replident == REPLICA_IDENTITY_FULL)
9186 {
9187 /*
9188 * When logging the entire old tuple, it very well could contain
9189 * toasted columns. If so, force them to be inlined.
9190 */
9192 {
9193 *copy = true;
9194 tp = toast_flatten_tuple(tp, desc);
9195 }
9196 return tp;
9197 }
9198
9199 /* if the key isn't required and we're only logging the key, we're done */
9200 if (!key_required)
9201 return NULL;
9202
9203 /* find out the replica identity columns */
9204 idattrs = RelationGetIndexAttrBitmap(relation,
9206
9207 /*
9208 * If there's no defined replica identity columns, treat as !key_required.
9209 * (This case should not be reachable from heap_update, since that should
9210 * calculate key_required accurately. But heap_delete just passes
9211 * constant true for key_required, so we can hit this case in deletes.)
9212 */
9214 return NULL;
9215
9216 /*
9217 * Construct a new tuple containing only the replica identity columns,
9218 * with nulls elsewhere. While we're at it, assert that the replica
9219 * identity columns aren't null.
9220 */
9222
9224 {
9226 idattrs))
9228 else
9230 }
9231
9233 *copy = true;
9234
9235 bms_free(idattrs);
9236
9237 /*
9238 * If the tuple, which by here only contains indexed columns, still has
9239 * toasted columns, force them to be inlined. This is somewhat unlikely
9240 * since there's limits on the size of indexed columns, so we don't
9241 * duplicate toast_flatten_tuple()s functionality in the above loop over
9242 * the indexed columns, even if it would be more efficient.
9243 */
9245 {
9246 HeapTuple oldtup = key_tuple;
9247
9248 key_tuple = toast_flatten_tuple(oldtup, desc);
9249 heap_freetuple(oldtup);
9250 }
9251
9252 return key_tuple;
9253}
HeapTuple toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)
Definition: heaptoast.c:350
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1117
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1346
static bool HeapTupleHasExternal(const HeapTupleData *tuple)
Definition: htup_details.h:762
Bitmapset * RelationGetIndexAttrBitmap(Relation relation, IndexAttrBitmapKind attrKind)
Definition: relcache.c:5303
Definition: bitmapset.h:50
Definition: htup.h:63
Definition: tupdesc.h:136
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27
References Assert(), bms_free(), bms_is_empty, bms_is_member(), FirstLowInvalidHeapAttributeNumber, heap_deform_tuple(), heap_form_tuple(), heap_freetuple(), HeapTupleHasExternal(), i, INDEX_ATTR_BITMAP_IDENTITY_KEY, MaxHeapAttributeNumber, TupleDescData::natts, RelationData::rd_rel, RelationGetDescr, RelationGetIndexAttrBitmap(), RelationIsLogicallyLogged, toast_flatten_tuple(), and values.
Referenced by heap_delete(), and heap_update().
◆ FreeBulkInsertState()
| void FreeBulkInsertState | ( | BulkInsertState | bistate | ) |
Definition at line 2053 of file heapam.c.
References BulkInsertStateData::current_buf, FreeAccessStrategy(), InvalidBuffer, pfree(), ReleaseBuffer(), and BulkInsertStateData::strategy.
Referenced by ATRewriteTable(), CopyFrom(), CopyMultiInsertBufferCleanup(), intorel_shutdown(), and transientrel_shutdown().
◆ FreezeMultiXactId()
|
static |
Definition at line 6730 of file heapam.c.
6733{
6734 TransactionId newxmax;
6735 MultiXactMember *members;
6736 int nmembers;
6737 bool need_replace;
6738 int nnewmembers;
6739 MultiXactMember *newmembers;
6740 bool has_lockers;
6741 TransactionId update_xid;
6742 bool update_committed;
6743 TransactionId FreezePageRelfrozenXid;
6744
6745 *flags = 0;
6746
6747 /* We should only be called in Multis */
6749
6751 HEAP_LOCKED_UPGRADED(t_infomask))
6752 {
6753 *flags |= FRM_INVALIDATE_XMAX;
6756 }
6761 multi, cutoffs->relminmxid)));
6763 {
6764 TransactionId update_xact;
6765
6766 /*
6767 * This old multi cannot possibly have members still running, but
6768 * verify just in case. If it was a locker only, it can be removed
6769 * without any further consideration; but if it contained an update,
6770 * we might need to preserve it.
6771 */
6773 HEAP_XMAX_IS_LOCKED_ONLY(t_infomask)))
6777 multi, cutoffs->OldestMxact)));
6778
6780 {
6781 *flags |= FRM_INVALIDATE_XMAX;
6784 }
6785
6786 /* replace multi with single XID for its updater? */
6787 update_xact = MultiXactIdGetUpdateXid(multi, t_infomask);
6792 multi, update_xact,
6793 cutoffs->relfrozenxid)));
6795 {
6796 /*
6797 * Updater XID has to have aborted (otherwise the tuple would have
6798 * been pruned away instead, since updater XID is < OldestXmin).
6799 * Just remove xmax.
6800 */
6804 errmsg_internal("multixact %u contains committed update XID %u from before removable cutoff %u",
6805 multi, update_xact,
6806 cutoffs->OldestXmin)));
6807 *flags |= FRM_INVALIDATE_XMAX;
6810 }
6811
6812 /* Have to keep updater XID as new xmax */
6813 *flags |= FRM_RETURN_IS_XID;
6815 return update_xact;
6816 }
6817
6818 /*
6819 * Some member(s) of this Multi may be below FreezeLimit xid cutoff, so we
6820 * need to walk the whole members array to figure out what to do, if
6821 * anything.
6822 */
6823 nmembers =
6825 HEAP_XMAX_IS_LOCKED_ONLY(t_infomask));
6826 if (nmembers <= 0)
6827 {
6828 /* Nothing worth keeping */
6829 *flags |= FRM_INVALIDATE_XMAX;
6832 }
6833
6834 /*
6835 * The FRM_NOOP case is the only case where we might need to ratchet back
6836 * FreezePageRelfrozenXid or FreezePageRelminMxid. It is also the only
6837 * case where our caller might ratchet back its NoFreezePageRelfrozenXid
6838 * or NoFreezePageRelminMxid "no freeze" trackers to deal with a multi.
6839 * FRM_NOOP handling should result in the NewRelfrozenXid/NewRelminMxid
6840 * trackers managed by VACUUM being ratcheting back by xmax to the degree
6841 * required to make it safe to leave xmax undisturbed, independent of
6842 * whether or not page freezing is triggered somewhere else.
6843 *
6844 * Our policy is to force freezing in every case other than FRM_NOOP,
6845 * which obviates the need to maintain either set of trackers, anywhere.
6846 * Every other case will reliably execute a freeze plan for xmax that
6847 * either replaces xmax with an XID/MXID >= OldestXmin/OldestMxact, or
6848 * sets xmax to an InvalidTransactionId XID, rendering xmax fully frozen.
6849 * (VACUUM's NewRelfrozenXid/NewRelminMxid trackers are initialized with
6850 * OldestXmin/OldestMxact, so later values never need to be tracked here.)
6851 */
6852 need_replace = false;
6853 FreezePageRelfrozenXid = pagefrz->FreezePageRelfrozenXid;
6855 {
6857
6859
6861 {
6862 /* Can't violate the FreezeLimit postcondition */
6863 need_replace = true;
6864 break;
6865 }
6867 FreezePageRelfrozenXid = xid;
6868 }
6869
6870 /* Can't violate the MultiXactCutoff postcondition, either */
6871 if (!need_replace)
6873
6874 if (!need_replace)
6875 {
6876 /*
6877 * vacuumlazy.c might ratchet back NewRelminMxid, NewRelfrozenXid, or
6878 * both together to make it safe to retain this particular multi after
6879 * freezing its page
6880 */
6881 *flags |= FRM_NOOP;
6882 pagefrz->FreezePageRelfrozenXid = FreezePageRelfrozenXid;
6884 pagefrz->FreezePageRelminMxid = multi;
6885 pfree(members);
6886 return multi;
6887 }
6888
6889 /*
6890 * Do a more thorough second pass over the multi to figure out which
6891 * member XIDs actually need to be kept. Checking the precise status of
6892 * individual members might even show that we don't need to keep anything.
6893 * That is quite possible even though the Multi must be >= OldestMxact,
6894 * since our second pass only keeps member XIDs when it's truly necessary;
6895 * even member XIDs >= OldestXmin often won't be kept by second pass.
6896 */
6897 nnewmembers = 0;
6899 has_lockers = false;
6900 update_xid = InvalidTransactionId;
6901 update_committed = false;
6902
6903 /*
6904 * Determine whether to keep each member xid, or to ignore it instead
6905 */
6907 {
6910
6912
6914 {
6915 /*
6916 * Locker XID (not updater XID). We only keep lockers that are
6917 * still running.
6918 */
6920 TransactionIdIsInProgress(xid))
6921 {
6926 multi, xid,
6927 cutoffs->OldestXmin)));
6928 newmembers[nnewmembers++] = members[i];
6929 has_lockers = true;
6930 }
6931
6932 continue;
6933 }
6934
6935 /*
6936 * Updater XID (not locker XID). Should we keep it?
6937 *
6938 * Since the tuple wasn't totally removed when vacuum pruned, the
6939 * update Xid cannot possibly be older than OldestXmin cutoff unless
6940 * the updater XID aborted. If the updater transaction is known
6941 * aborted or crashed then it's okay to ignore it, otherwise not.
6942 *
6943 * In any case the Multi should never contain two updaters, whatever
6944 * their individual commit status. Check for that first, in passing.
6945 */
6950 multi),
6952 update_xid, xid)));
6953
6954 /*
6955 * As with all tuple visibility routines, it's critical to test
6956 * TransactionIdIsInProgress before TransactionIdDidCommit, because of
6957 * race conditions explained in detail in heapam_visibility.c.
6958 */
6960 TransactionIdIsInProgress(xid))
6961 update_xid = xid;
6963 {
6964 /*
6965 * The transaction committed, so we can tell caller to set
6966 * HEAP_XMAX_COMMITTED. (We can only do this because we know the
6967 * transaction is not running.)
6968 */
6969 update_committed = true;
6970 update_xid = xid;
6971 }
6972 else
6973 {
6974 /*
6975 * Not in progress, not committed -- must be aborted or crashed;
6976 * we can ignore it.
6977 */
6978 continue;
6979 }
6980
6981 /*
6982 * We determined that updater must be kept -- add it to pending new
6983 * members list
6984 */
6988 errmsg_internal("multixact %u contains committed update XID %u from before removable cutoff %u",
6989 multi, xid, cutoffs->OldestXmin)));
6990 newmembers[nnewmembers++] = members[i];
6991 }
6992
6993 pfree(members);
6994
6995 /*
6996 * Determine what to do with caller's multi based on information gathered
6997 * during our second pass
6998 */
6999 if (nnewmembers == 0)
7000 {
7001 /* Nothing worth keeping */
7002 *flags |= FRM_INVALIDATE_XMAX;
7003 newxmax = InvalidTransactionId;
7004 }
7006 {
7007 /*
7008 * If there's a single member and it's an update, pass it back alone
7009 * without creating a new Multi. (XXX we could do this when there's a
7010 * single remaining locker, too, but that would complicate the API too
7011 * much; moreover, the case with the single updater is more
7012 * interesting, because those are longer-lived.)
7013 */
7014 Assert(nnewmembers == 1);
7015 *flags |= FRM_RETURN_IS_XID;
7016 if (update_committed)
7017 *flags |= FRM_MARK_COMMITTED;
7018 newxmax = update_xid;
7019 }
7020 else
7021 {
7022 /*
7023 * Create a new multixact with the surviving members of the previous
7024 * one, to set as new Xmax in the tuple
7025 */
7026 newxmax = MultiXactIdCreateFromMembers(nnewmembers, newmembers);
7027 *flags |= FRM_RETURN_IS_MULTI;
7028 }
7029
7030 pfree(newmembers);
7031
7033 return newxmax;
7034}
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:3269
MultiXactId MultiXactIdCreateFromMembers(int nmembers, MultiXactMember *members)
Definition: multixact.c:799
static bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.h:263
References Assert(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errdetail_internal(), errmsg_internal(), ERROR, HeapPageFreeze::freeze_required, VacuumCutoffs::FreezeLimit, HeapPageFreeze::FreezePageRelfrozenXid, HeapPageFreeze::FreezePageRelminMxid, FRM_INVALIDATE_XMAX, FRM_MARK_COMMITTED, FRM_NOOP, FRM_RETURN_IS_MULTI, FRM_RETURN_IS_XID, GetMultiXactIdMembers(), HEAP_LOCKED_UPGRADED(), HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, i, InvalidTransactionId, ISUPDATE_from_mxstatus, VacuumCutoffs::MultiXactCutoff, MultiXactIdCreateFromMembers(), MultiXactIdGetUpdateXid(), MultiXactIdIsRunning(), MultiXactIdIsValid, MultiXactIdPrecedes(), VacuumCutoffs::OldestMxact, VacuumCutoffs::OldestXmin, palloc(), pfree(), VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, MultiXactMember::status, TransactionIdDidCommit(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), TransactionIdIsValid, TransactionIdPrecedes(), and MultiXactMember::xid.
Referenced by heap_prepare_freeze_tuple().
◆ get_mxact_status_for_lock()
|
static |
Definition at line 4558 of file heapam.c.
4559{
4560 int retval;
4561
4562 if (is_update)
4564 else
4566
4567 if (retval == -1)
4569 is_update ? "true" : "false");
4570
4572}
References elog, ERROR, mode, and tupleLockExtraInfo.
Referenced by compute_new_xmax_infomask(), heap_lock_tuple(), and test_lockmode_for_conflict().
◆ GetBulkInsertState()
| BulkInsertState GetBulkInsertState | ( | void | ) |
Definition at line 2036 of file heapam.c.
2037{
2038 BulkInsertState bistate;
2039
2045 bistate->already_extended_by = 0;
2046 return bistate;
2047}
BufferAccessStrategy GetAccessStrategy(BufferAccessStrategyType btype)
Definition: freelist.c:461
Definition: hio.h:30
References BulkInsertStateData::already_extended_by, BAS_BULKWRITE, BulkInsertStateData::current_buf, GetAccessStrategy(), InvalidBlockNumber, InvalidBuffer, BulkInsertStateData::last_free, BulkInsertStateData::next_free, palloc(), and BulkInsertStateData::strategy.
Referenced by ATRewriteTable(), CopyFrom(), CopyMultiInsertBufferInit(), intorel_startup(), and transientrel_startup().
◆ GetMultiXactIdHintBits()
|
static |
Definition at line 7472 of file heapam.c.
7474{
7475 int nmembers;
7476 MultiXactMember *members;
7479 uint16 bits2 = 0;
7480 bool has_update = false;
7482
7483 /*
7484 * We only use this in multis we just created, so they cannot be values
7485 * pre-pg_upgrade.
7486 */
7488
7490 {
7492
7493 /*
7494 * Remember the strongest lock mode held by any member of the
7495 * multixact.
7496 */
7499 strongest = mode;
7500
7501 /* See what other bits we need */
7503 {
7507 break;
7508
7510 bits2 |= HEAP_KEYS_UPDATED;
7511 break;
7512
7514 has_update = true;
7515 break;
7516
7518 bits2 |= HEAP_KEYS_UPDATED;
7519 has_update = true;
7520 break;
7521 }
7522 }
7523
7525 strongest == LockTupleNoKeyExclusive)
7526 bits |= HEAP_XMAX_EXCL_LOCK;
7528 bits |= HEAP_XMAX_SHR_LOCK;
7530 bits |= HEAP_XMAX_KEYSHR_LOCK;
7531
7532 if (!has_update)
7533 bits |= HEAP_XMAX_LOCK_ONLY;
7534
7535 if (nmembers > 0)
7536 pfree(members);
7537
7538 *new_infomask = bits;
7539 *new_infomask2 = bits2;
7540}
References GetMultiXactIdMembers(), HEAP_KEYS_UPDATED, HEAP_XMAX_EXCL_LOCK, HEAP_XMAX_IS_MULTI, HEAP_XMAX_KEYSHR_LOCK, HEAP_XMAX_LOCK_ONLY, HEAP_XMAX_SHR_LOCK, i, LockTupleExclusive, LockTupleKeyShare, LockTupleNoKeyExclusive, LockTupleShare, mode, MultiXactStatusForKeyShare, MultiXactStatusForNoKeyUpdate, MultiXactStatusForShare, MultiXactStatusForUpdate, MultiXactStatusNoKeyUpdate, MultiXactStatusUpdate, pfree(), and TUPLOCK_from_mxstatus.
Referenced by compute_new_xmax_infomask(), heap_prepare_freeze_tuple(), and heap_update().
◆ heap_abort_speculative()
| void heap_abort_speculative | ( | Relation | relation, |
| const ItemPointerData * | tid | ||
| ) |
Definition at line 6201 of file heapam.c.
6202{
6204 ItemId lp;
6205 HeapTupleData tp;
6206 Page page;
6207 BlockNumber block;
6208 Buffer buffer;
6209
6211
6212 block = ItemPointerGetBlockNumber(tid);
6213 buffer = ReadBuffer(relation, block);
6214 page = BufferGetPage(buffer);
6215
6217
6218 /*
6219 * Page can't be all visible, we just inserted into it, and are still
6220 * running.
6221 */
6223
6226
6230 tp.t_self = *tid;
6231
6232 /*
6233 * Sanity check that the tuple really is a speculatively inserted tuple,
6234 * inserted by us.
6235 */
6241
6242 /*
6243 * No need to check for serializable conflicts here. There is never a
6244 * need for a combo CID, either. No need to extract replica identity, or
6245 * do anything special with infomask bits.
6246 */
6247
6248 START_CRIT_SECTION();
6249
6250 /*
6251 * The tuple will become DEAD immediately. Flag that this page is a
6252 * candidate for pruning by setting xmin to TransactionXmin. While not
6253 * immediately prunable, it is the oldest xid we can cheaply determine
6254 * that's safe against wraparound / being older than the table's
6255 * relfrozenxid. To defend against the unlikely case of a new relation
6256 * having a newer relfrozenxid than our TransactionXmin, use relfrozenxid
6257 * if so (vacuum can't subsequently move relfrozenxid to beyond
6258 * TransactionXmin, so there's no race here).
6259 */
6261 {
6263 TransactionId prune_xid;
6264
6266 prune_xid = relfrozenxid;
6267 else
6268 prune_xid = TransactionXmin;
6269 PageSetPrunable(page, prune_xid);
6270 }
6271
6272 /* store transaction information of xact deleting the tuple */
6275
6276 /*
6277 * Set the tuple header xmin to InvalidTransactionId. This makes the
6278 * tuple immediately invisible everyone. (In particular, to any
6279 * transactions waiting on the speculative token, woken up later.)
6280 */
6282
6283 /* Clear the speculative insertion token too */
6285
6286 MarkBufferDirty(buffer);
6287
6288 /*
6289 * XLOG stuff
6290 *
6291 * The WAL records generated here match heap_delete(). The same recovery
6292 * routines are used.
6293 */
6295 {
6296 xl_heap_delete xlrec;
6297 XLogRecPtr recptr;
6298
6303 xlrec.xmax = xid;
6304
6305 XLogBeginInsert();
6308
6309 /* No replica identity & replication origin logged */
6310
6312
6313 PageSetLSN(page, recptr);
6314 }
6315
6316 END_CRIT_SECTION();
6317
6319
6321 {
6324 }
6325
6326 /*
6327 * Never need to mark tuple for invalidation, since catalogs don't support
6328 * speculative insertion
6329 */
6330
6331 /* Now we can release the buffer */
6332 ReleaseBuffer(buffer);
6333
6334 /* count deletion, as we counted the insertion too */
6335 pgstat_count_heap_delete(relation);
6336}
static void * PageGetItem(const PageData *page, const ItemIdData *itemId)
Definition: bufpage.h:353
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:243
static uint8 compute_infobits(uint16 infomask, uint16 infomask2)
Definition: heapam.c:2759
void heap_toast_delete(Relation rel, HeapTuple oldtup, bool is_speculative)
Definition: heaptoast.c:43
static bool HeapTupleHeaderIsHeapOnly(const HeapTupleHeaderData *tup)
Definition: htup_details.h:555
static bool HeapTupleHeaderIsSpeculative(const HeapTupleHeaderData *tup)
Definition: htup_details.h:461
static void HeapTupleHeaderSetXmin(HeapTupleHeaderData *tup, TransactionId xid)
Definition: htup_details.h:331
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
Definition: itemptr.h:124
static bool ItemPointerIsValid(const ItemPointerData *pointer)
Definition: itemptr.h:83
void pgstat_count_heap_delete(Relation rel)
Definition: pgstat_relation.c:415
union HeapTupleHeaderData::@49 t_choice
Definition: itemid.h:26
Definition: heapam_xlog.h:114
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:245
References Assert(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetPage(), compute_infobits(), elog, END_CRIT_SECTION, ERROR, xl_heap_delete::flags, GetCurrentTransactionId(), HEAP_MOVED, heap_toast_delete(), HEAP_XMAX_BITS, HeapTupleHasExternal(), HeapTupleHeaderIsHeapOnly(), HeapTupleHeaderIsSpeculative(), HeapTupleHeaderSetXmin(), xl_heap_delete::infobits_set, InvalidTransactionId, IsToastRelation(), ItemIdGetLength, ItemIdIsNormal, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), MarkBufferDirty(), xl_heap_delete::offnum, PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetLSN(), PageSetPrunable, pgstat_count_heap_delete(), RelationData::rd_rel, ReadBuffer(), REGBUF_STANDARD, RelationGetRelid, RelationNeedsWAL, ReleaseBuffer(), SizeOfHeapDelete, START_CRIT_SECTION, HeapTupleHeaderData::t_choice, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_heap, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, HeapTupleFields::t_xmin, TransactionIdIsValid, TransactionIdPrecedes(), TransactionXmin, XLH_DELETE_IS_SUPER, XLOG_HEAP_DELETE, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), and xl_heap_delete::xmax.
Referenced by heapam_tuple_complete_speculative(), and toast_delete_datum().
◆ heap_acquire_tuplock()
|
static |
Definition at line 5303 of file heapam.c.
5305{
5306 if (*have_tuple_lock)
5307 return true;
5308
5309 switch (wait_policy)
5310 {
5313 break;
5314
5317 return false;
5318 break;
5319
5323 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
5325 RelationGetRelationName(relation))));
5326 break;
5327 }
5328 *have_tuple_lock = true;
5329
5330 return true;
5331}
#define ConditionalLockTupleTuplock(rel, tup, mode, log)
Definition: heapam.c:166
References ConditionalLockTupleTuplock, ereport, errcode(), errmsg(), ERROR, LockTupleTuplock, LockWaitBlock, LockWaitError, LockWaitSkip, log_lock_failures, mode, and RelationGetRelationName.
Referenced by heap_delete(), heap_lock_tuple(), and heap_update().
◆ heap_attr_equals()
|
static |
Definition at line 4376 of file heapam.c.
4378{
4379 /*
4380 * If one value is NULL and other is not, then they are certainly not
4381 * equal
4382 */
4383 if (isnull1 != isnull2)
4384 return false;
4385
4386 /*
4387 * If both are NULL, they can be considered equal.
4388 */
4389 if (isnull1)
4390 return true;
4391
4392 /*
4393 * We do simple binary comparison of the two datums. This may be overly
4394 * strict because there can be multiple binary representations for the
4395 * same logical value. But we should be OK as long as there are no false
4396 * positives. Using a type-specific equality operator is messy because
4397 * there could be multiple notions of equality in different operator
4398 * classes; furthermore, we cannot safely invoke user-defined functions
4399 * while holding exclusive buffer lock.
4400 */
4401 if (attrnum <= 0)
4402 {
4403 /* The only allowed system columns are OIDs, so do this */
4405 }
4406 else
4407 {
4408 CompactAttribute *att;
4409
4410 Assert(attrnum <= tupdesc->natts);
4411 att = TupleDescCompactAttr(tupdesc, attrnum - 1);
4413 }
4414}
bool datumIsEqual(Datum value1, Datum value2, bool typByVal, int typLen)
Definition: datum.c:223
Definition: tupdesc.h:69
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:175
References Assert(), CompactAttribute::attbyval, CompactAttribute::attlen, DatumGetObjectId(), datumIsEqual(), and TupleDescCompactAttr().
Referenced by HeapDetermineColumnsInfo().
◆ heap_beginscan()
| TableScanDesc heap_beginscan | ( | Relation | relation, |
| Snapshot | snapshot, | ||
| int | nkeys, | ||
| ScanKey | key, | ||
| ParallelTableScanDesc | parallel_scan, | ||
| uint32 | flags | ||
| ) |
Definition at line 1115 of file heapam.c.
1119{
1120 HeapScanDesc scan;
1121
1122 /*
1123 * increment relation ref count while scanning relation
1124 *
1125 * This is just to make really sure the relcache entry won't go away while
1126 * the scan has a pointer to it. Caller should be holding the rel open
1127 * anyway, so this is redundant in all normal scenarios...
1128 */
1129 RelationIncrementReferenceCount(relation);
1130
1131 /*
1132 * allocate and initialize scan descriptor
1133 */
1135 {
1137
1138 /*
1139 * Bitmap Heap scans do not have any fields that a normal Heap Scan
1140 * does not have, so no special initializations required here.
1141 */
1142 scan = (HeapScanDesc) bscan;
1143 }
1144 else
1146
1154
1155 /*
1156 * Disable page-at-a-time mode if it's not a MVCC-safe snapshot.
1157 */
1160
1161 /* Check that a historic snapshot is not used for non-catalog tables */
1162 if (snapshot &&
1163 IsHistoricMVCCSnapshot(snapshot) &&
1164 !RelationIsAccessibleInLogicalDecoding(relation))
1165 {
1167 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
1169 RelationGetRelationName(relation))));
1170 }
1171
1172 /*
1173 * For seqscan and sample scans in a serializable transaction, acquire a
1174 * predicate lock on the entire relation. This is required not only to
1175 * lock all the matching tuples, but also to conflict with new insertions
1176 * into the table. In an indexscan, we take page locks on the index pages
1177 * covering the range specified in the scan qual, but in a heap scan there
1178 * is nothing more fine-grained to lock. A bitmap scan is a different
1179 * story, there we have already scanned the index and locked the index
1180 * pages covering the predicate. But in that case we still have to lock
1181 * any matching heap tuples. For sample scan we could optimize the locking
1182 * to be at least page-level granularity, but we'd need to add per-tuple
1183 * locking for that.
1184 */
1186 {
1187 /*
1188 * Ensure a missing snapshot is noticed reliably, even if the
1189 * isolation mode means predicate locking isn't performed (and
1190 * therefore the snapshot isn't used here).
1191 */
1192 Assert(snapshot);
1193 PredicateLockRelation(relation, snapshot);
1194 }
1195
1196 /* we only need to set this up once */
1198
1199 /*
1200 * Allocate memory to keep track of page allocation for parallel workers
1201 * when doing a parallel scan.
1202 */
1203 if (parallel_scan != NULL)
1205 else
1206 scan->rs_parallelworkerdata = NULL;
1207
1208 /*
1209 * we do this here instead of in initscan() because heap_rescan also calls
1210 * initscan() and we don't want to allocate memory again
1211 */
1212 if (nkeys > 0)
1214 else
1216
1218
1219 scan->rs_read_stream = NULL;
1220
1221 /*
1222 * Set up a read stream for sequential scans and TID range scans. This
1223 * should be done after initscan() because initscan() allocates the
1224 * BufferAccessStrategy object passed to the read stream API.
1225 */
1228 {
1229 ReadStreamBlockNumberCB cb;
1230
1232 cb = heap_scan_stream_read_next_parallel;
1233 else
1234 cb = heap_scan_stream_read_next_serial;
1235
1236 /* ---
1237 * It is safe to use batchmode as the only locks taken by `cb`
1238 * are never taken while waiting for IO:
1239 * - SyncScanLock is used in the non-parallel case
1240 * - in the parallel case, only spinlocks and atomics are used
1241 * ---
1242 */
1244 READ_STREAM_USE_BATCHING,
1245 scan->rs_strategy,
1247 MAIN_FORKNUM,
1248 cb,
1249 scan,
1250 0);
1251 }
1253 {
1255 READ_STREAM_USE_BATCHING,
1256 scan->rs_strategy,
1258 MAIN_FORKNUM,
1260 scan,
1262 }
1263
1264
1266}
static BlockNumber heap_scan_stream_read_next_parallel(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition: heapam.c:247
static BlockNumber heap_scan_stream_read_next_serial(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition: heapam.c:287
static BlockNumber bitmapheap_stream_read_next(ReadStream *pgsr, void *private_data, void *per_buffer_data)
Definition: heapam.c:312
static void initscan(HeapScanDesc scan, ScanKey key, bool keep_startblock)
Definition: heapam.c:352
void PredicateLockRelation(Relation relation, Snapshot snapshot)
Definition: predicate.c:2576
ReadStream * read_stream_begin_relation(int flags, BufferAccessStrategy strategy, Relation rel, ForkNumber forknum, ReadStreamBlockNumberCB callback, void *callback_private_data, size_t per_buffer_data_size)
Definition: read_stream.c:737
BlockNumber(* ReadStreamBlockNumberCB)(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition: read_stream.h:77
#define RelationIsAccessibleInLogicalDecoding(relation)
Definition: rel.h:694
void RelationIncrementReferenceCount(Relation rel)
Definition: relcache.c:2187
ParallelBlockTableScanWorkerData * rs_parallelworkerdata
Definition: heapam.h:95
Definition: relscan.h:110
Definition: skey.h:65
struct ParallelTableScanDescData * rs_parallel
Definition: relscan.h:66
References Assert(), bitmapheap_stream_read_next(), ereport, errcode(), errmsg(), ERROR, heap_scan_stream_read_next_parallel(), heap_scan_stream_read_next_serial(), initscan(), InvalidBuffer, IsHistoricMVCCSnapshot, IsMVCCSnapshot, sort-test::key, MAIN_FORKNUM, palloc(), PredicateLockRelation(), read_stream_begin_relation(), READ_STREAM_DEFAULT, READ_STREAM_SEQUENTIAL, READ_STREAM_USE_BATCHING, RelationGetRelationName, RelationGetRelid, RelationIncrementReferenceCount(), RelationIsAccessibleInLogicalDecoding, HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_nkeys, TableScanDescData::rs_parallel, HeapScanDescData::rs_parallelworkerdata, TableScanDescData::rs_rd, HeapScanDescData::rs_read_stream, TableScanDescData::rs_snapshot, HeapScanDescData::rs_strategy, SO_TYPE_BITMAPSCAN, SO_TYPE_SAMPLESCAN, SO_TYPE_SEQSCAN, SO_TYPE_TIDRANGESCAN, and HeapTupleData::t_tableOid.
◆ heap_delete()
| TM_Result heap_delete | ( | Relation | relation, |
| const ItemPointerData * | tid, | ||
| CommandId | cid, | ||
| Snapshot | crosscheck, | ||
| bool | wait, | ||
| TM_FailureData * | tmfd, | ||
| bool | changingPart | ||
| ) |
Definition at line 2804 of file heapam.c.
2807{
2808 TM_Result result;
2810 ItemId lp;
2811 HeapTupleData tp;
2812 Page page;
2813 BlockNumber block;
2814 Buffer buffer;
2816 TransactionId new_xmax;
2817 uint16 new_infomask,
2818 new_infomask2;
2819 bool have_tuple_lock = false;
2820 bool iscombo;
2821 bool all_visible_cleared = false;
2823 bool old_key_copied = false;
2824
2826
2827 AssertHasSnapshotForToast(relation);
2828
2829 /*
2830 * Forbid this during a parallel operation, lest it allocate a combo CID.
2831 * Other workers might need that combo CID for visibility checks, and we
2832 * have no provision for broadcasting it to them.
2833 */
2836 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
2838
2839 block = ItemPointerGetBlockNumber(tid);
2840 buffer = ReadBuffer(relation, block);
2841 page = BufferGetPage(buffer);
2842
2843 /*
2844 * Before locking the buffer, pin the visibility map page if it appears to
2845 * be necessary. Since we haven't got the lock yet, someone else might be
2846 * in the middle of changing this, so we'll need to recheck after we have
2847 * the lock.
2848 */
2850 visibilitymap_pin(relation, block, &vmbuffer);
2851
2853
2856
2860 tp.t_self = *tid;
2861
2862l1:
2863
2864 /*
2865 * If we didn't pin the visibility map page and the page has become all
2866 * visible while we were busy locking the buffer, we'll have to unlock and
2867 * re-lock, to avoid holding the buffer lock across an I/O. That's a bit
2868 * unfortunate, but hopefully shouldn't happen often.
2869 */
2871 {
2873 visibilitymap_pin(relation, block, &vmbuffer);
2875 }
2876
2877 result = HeapTupleSatisfiesUpdate(&tp, cid, buffer);
2878
2880 {
2881 UnlockReleaseBuffer(buffer);
2883 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
2885 }
2887 {
2888 TransactionId xwait;
2889 uint16 infomask;
2890
2891 /* must copy state data before unlocking buffer */
2894
2895 /*
2896 * Sleep until concurrent transaction ends -- except when there's a
2897 * single locker and it's our own transaction. Note we don't care
2898 * which lock mode the locker has, because we need the strongest one.
2899 *
2900 * Before sleeping, we need to acquire tuple lock to establish our
2901 * priority for the tuple (see heap_lock_tuple). LockTuple will
2902 * release us when we are next-in-line for the tuple.
2903 *
2904 * If we are forced to "start over" below, we keep the tuple lock;
2905 * this arranges that we stay at the head of the line while rechecking
2906 * tuple state.
2907 */
2909 {
2910 bool current_is_member = false;
2911
2913 LockTupleExclusive, ¤t_is_member))
2914 {
2916
2917 /*
2918 * Acquire the lock, if necessary (but skip it when we're
2919 * requesting a lock and already have one; avoids deadlock).
2920 */
2921 if (!current_is_member)
2923 LockWaitBlock, &have_tuple_lock);
2924
2925 /* wait for multixact */
2928 NULL);
2930
2931 /*
2932 * If xwait had just locked the tuple then some other xact
2933 * could update this tuple before we get to this point. Check
2934 * for xmax change, and start over if so.
2935 *
2936 * We also must start over if we didn't pin the VM page, and
2937 * the page has become all visible.
2938 */
2942 xwait))
2943 goto l1;
2944 }
2945
2946 /*
2947 * You might think the multixact is necessarily done here, but not
2948 * so: it could have surviving members, namely our own xact or
2949 * other subxacts of this backend. It is legal for us to delete
2950 * the tuple in either case, however (the latter case is
2951 * essentially a situation of upgrading our former shared lock to
2952 * exclusive). We don't bother changing the on-disk hint bits
2953 * since we are about to overwrite the xmax altogether.
2954 */
2955 }
2957 {
2958 /*
2959 * Wait for regular transaction to end; but first, acquire tuple
2960 * lock.
2961 */
2964 LockWaitBlock, &have_tuple_lock);
2967
2968 /*
2969 * xwait is done, but if xwait had just locked the tuple then some
2970 * other xact could update this tuple before we get to this point.
2971 * Check for xmax change, and start over if so.
2972 *
2973 * We also must start over if we didn't pin the VM page, and the
2974 * page has become all visible.
2975 */
2979 xwait))
2980 goto l1;
2981
2982 /* Otherwise check if it committed or aborted */
2984 }
2985
2986 /*
2987 * We may overwrite if previous xmax aborted, or if it committed but
2988 * only locked the tuple without updating it.
2989 */
2993 result = TM_Ok;
2995 result = TM_Updated;
2996 else
2997 result = TM_Deleted;
2998 }
2999
3000 /* sanity check the result HeapTupleSatisfiesUpdate() and the logic above */
3002 {
3004 result == TM_Updated ||
3005 result == TM_Deleted ||
3006 result == TM_BeingModified);
3010 }
3011
3013 {
3014 /* Perform additional check for transaction-snapshot mode RI updates */
3016 result = TM_Updated;
3017 }
3018
3020 {
3025 else
3027 UnlockReleaseBuffer(buffer);
3028 if (have_tuple_lock)
3031 ReleaseBuffer(vmbuffer);
3032 return result;
3033 }
3034
3035 /*
3036 * We're about to do the actual delete -- check for conflict first, to
3037 * avoid possibly having to roll back work we've just done.
3038 *
3039 * This is safe without a recheck as long as there is no possibility of
3040 * another process scanning the page between this check and the delete
3041 * being visible to the scan (i.e., an exclusive buffer content lock is
3042 * continuously held from this point until the tuple delete is visible).
3043 */
3045
3046 /* replace cid with a combo CID if necessary */
3048
3049 /*
3050 * Compute replica identity tuple before entering the critical section so
3051 * we don't PANIC upon a memory allocation failure.
3052 */
3054
3055 /*
3056 * If this is the first possibly-multixact-able operation in the current
3057 * transaction, set my per-backend OldestMemberMXactId setting. We can be
3058 * certain that the transaction will never become a member of any older
3059 * MultiXactIds than that. (We have to do this even if we end up just
3060 * using our own TransactionId below, since some other backend could
3061 * incorporate our XID into a MultiXact immediately afterwards.)
3062 */
3063 MultiXactIdSetOldestMember();
3064
3068 &new_xmax, &new_infomask, &new_infomask2);
3069
3070 START_CRIT_SECTION();
3071
3072 /*
3073 * If this transaction commits, the tuple will become DEAD sooner or
3074 * later. Set flag that this page is a candidate for pruning once our xid
3075 * falls below the OldestXmin horizon. If the transaction finally aborts,
3076 * the subsequent page pruning will be a no-op and the hint will be
3077 * cleared.
3078 */
3079 PageSetPrunable(page, xid);
3080
3082 {
3083 all_visible_cleared = true;
3084 PageClearAllVisible(page);
3086 vmbuffer, VISIBILITYMAP_VALID_BITS);
3087 }
3088
3089 /* store transaction information of xact deleting the tuple */
3097 /* Make sure there is no forward chain link in t_ctid */
3099
3100 /* Signal that this is actually a move into another partition */
3101 if (changingPart)
3103
3104 MarkBufferDirty(buffer);
3105
3106 /*
3107 * XLOG stuff
3108 *
3109 * NB: heap_abort_speculative() uses the same xlog record and replay
3110 * routines.
3111 */
3113 {
3114 xl_heap_delete xlrec;
3115 xl_heap_header xlhdr;
3116 XLogRecPtr recptr;
3117
3118 /*
3119 * For logical decode we need combo CIDs to properly decode the
3120 * catalog
3121 */
3123 log_heap_new_cid(relation, &tp);
3124
3125 xlrec.flags = 0;
3126 if (all_visible_cleared)
3128 if (changingPart)
3133 xlrec.xmax = new_xmax;
3134
3135 if (old_key_tuple != NULL)
3136 {
3139 else
3141 }
3142
3143 XLogBeginInsert();
3145
3147
3148 /*
3149 * Log replica identity of the deleted tuple if there is one
3150 */
3151 if (old_key_tuple != NULL)
3152 {
3156
3159 + SizeofHeapTupleHeader,
3160 old_key_tuple->t_len
3161 - SizeofHeapTupleHeader);
3162 }
3163
3164 /* filtering by origin on a row level is much more efficient */
3166
3168
3169 PageSetLSN(page, recptr);
3170 }
3171
3172 END_CRIT_SECTION();
3173
3175
3177 ReleaseBuffer(vmbuffer);
3178
3179 /*
3180 * If the tuple has toasted out-of-line attributes, we need to delete
3181 * those items too. We have to do this before releasing the buffer
3182 * because we need to look at the contents of the tuple, but it's OK to
3183 * release the content lock on the buffer first.
3184 */
3186 relation->rd_rel->relkind != RELKIND_MATVIEW)
3187 {
3188 /* toast table entries should never be recursively toasted */
3190 }
3193
3194 /*
3195 * Mark tuple for invalidation from system caches at next command
3196 * boundary. We have to do this before releasing the buffer because we
3197 * need to look at the contents of the tuple.
3198 */
3199 CacheInvalidateHeapTuple(relation, &tp, NULL);
3200
3201 /* Now we can release the buffer */
3202 ReleaseBuffer(buffer);
3203
3204 /*
3205 * Release the lmgr tuple lock, if we had it.
3206 */
3207 if (have_tuple_lock)
3209
3210 pgstat_count_heap_delete(relation);
3211
3212 if (old_key_tuple != NULL && old_key_copied)
3213 heap_freetuple(old_key_tuple);
3214
3216}
void HeapTupleHeaderAdjustCmax(const HeapTupleHeaderData *tup, CommandId *cmax, bool *iscombo)
Definition: combocid.c:153
CommandId HeapTupleHeaderGetCmax(const HeapTupleHeaderData *tup)
Definition: combocid.c:118
static bool DoesMultiXactIdConflict(MultiXactId multi, uint16 infomask, LockTupleMode lockmode, bool *current_is_member)
Definition: heapam.c:7621
static XLogRecPtr log_heap_new_cid(Relation relation, HeapTuple tup)
Definition: heapam.c:9086
static void compute_new_xmax_infomask(TransactionId xmax, uint16 old_infomask, uint16 old_infomask2, TransactionId add_to_xmax, LockTupleMode mode, bool is_update, TransactionId *result_xmax, uint16 *result_infomask, uint16 *result_infomask2)
Definition: heapam.c:5352
static bool heap_acquire_tuplock(Relation relation, const ItemPointerData *tid, LockTupleMode mode, LockWaitPolicy wait_policy, bool *have_tuple_lock)
Definition: heapam.c:5303
static HeapTuple ExtractReplicaIdentity(Relation relation, HeapTuple tp, bool key_required, bool *copy)
Definition: heapam.c:9167
static void MultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, Relation rel, const ItemPointerData *ctid, XLTW_Oper oper, int *remaining)
Definition: heapam.c:7799
static bool xmax_infomask_changed(uint16 new_infomask, uint16 old_infomask)
Definition: heapam.c:2781
static void AssertHasSnapshotForToast(Relation rel)
Definition: heapam.c:220
static void UpdateXmaxHintBits(HeapTupleHeader tuple, Buffer buffer, TransactionId xid)
Definition: heapam.c:2014
bool HeapTupleSatisfiesVisibility(HeapTuple htup, Snapshot snapshot, Buffer buffer)
Definition: heapam_visibility.c:1776
bool HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
Definition: heapam_visibility.c:1529
TM_Result HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid, Buffer buffer)
Definition: heapam_visibility.c:458
static void HeapTupleHeaderSetCmax(HeapTupleHeaderData *tup, CommandId cid, bool iscombo)
Definition: htup_details.h:431
static void HeapTupleHeaderClearHotUpdated(HeapTupleHeaderData *tup)
Definition: htup_details.h:549
static TransactionId HeapTupleHeaderGetRawXmax(const HeapTupleHeaderData *tup)
Definition: htup_details.h:377
static TransactionId HeapTupleHeaderGetUpdateXid(const HeapTupleHeaderData *tup)
Definition: htup_details.h:397
static void HeapTupleHeaderSetMovedPartitions(HeapTupleHeaderData *tup)
Definition: htup_details.h:486
static void HeapTupleHeaderSetXmax(HeapTupleHeaderData *tup, TransactionId xid)
Definition: htup_details.h:383
void CacheInvalidateHeapTuple(Relation relation, HeapTuple tuple, HeapTuple newtuple)
Definition: inval.c:1571
bool ItemPointerEquals(const ItemPointerData *pointer1, const ItemPointerData *pointer2)
Definition: itemptr.c:35
void CheckForSerializableConflictIn(Relation relation, const ItemPointerData *tid, BlockNumber blkno)
Definition: predicate.c:4336
Definition: heapam_xlog.h:151
bool visibilitymap_clear(Relation rel, BlockNumber heapBlk, Buffer vmbuf, uint8 flags)
Definition: visibilitymap.c:139
void visibilitymap_pin(Relation rel, BlockNumber heapBlk, Buffer *vmbuf)
Definition: visibilitymap.c:192
References Assert(), AssertHasSnapshotForToast(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), CacheInvalidateHeapTuple(), CheckForSerializableConflictIn(), TM_FailureData::cmax, compute_infobits(), compute_new_xmax_infomask(), TM_FailureData::ctid, DoesMultiXactIdConflict(), END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, ExtractReplicaIdentity(), xl_heap_delete::flags, GetCurrentTransactionId(), heap_acquire_tuplock(), heap_freetuple(), HEAP_MOVED, heap_toast_delete(), HEAP_XMAX_BITS, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HeapTupleHasExternal(), HeapTupleHeaderAdjustCmax(), HeapTupleHeaderClearHotUpdated(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderIsOnlyLocked(), HeapTupleHeaderSetCmax(), HeapTupleHeaderSetMovedPartitions(), HeapTupleHeaderSetXmax(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVisibility(), xl_heap_delete::infobits_set, InvalidBuffer, InvalidCommandId, InvalidSnapshot, IsInParallelMode(), ItemIdGetLength, ItemIdIsNormal, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), LockTupleExclusive, LockWaitBlock, log_heap_new_cid(), MarkBufferDirty(), MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusUpdate, xl_heap_delete::offnum, PageClearAllVisible(), PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetLSN(), PageSetPrunable, pgstat_count_heap_delete(), RelationData::rd_rel, ReadBuffer(), REGBUF_STANDARD, RelationGetRelid, RelationIsAccessibleInLogicalDecoding, RelationNeedsWAL, ReleaseBuffer(), SizeOfHeapDelete, SizeOfHeapHeader, SizeofHeapTupleHeader, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, xl_heap_header::t_hoff, HeapTupleHeaderData::t_hoff, xl_heap_header::t_infomask, HeapTupleHeaderData::t_infomask, xl_heap_header::t_infomask2, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TM_BeingModified, TM_Deleted, TM_Invisible, TM_Ok, TM_SelfModified, TM_Updated, TransactionIdEquals, TransactionIdIsCurrentTransactionId(), UnlockReleaseBuffer(), UnlockTupleTuplock, UpdateXmaxHintBits(), visibilitymap_clear(), visibilitymap_pin(), VISIBILITYMAP_VALID_BITS, XactLockTableWait(), XLH_DELETE_ALL_VISIBLE_CLEARED, XLH_DELETE_CONTAINS_OLD_KEY, XLH_DELETE_CONTAINS_OLD_TUPLE, XLH_DELETE_IS_PARTITION_MOVE, XLOG_HEAP_DELETE, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), XLogSetRecordFlags(), XLTW_Delete, xl_heap_delete::xmax, TM_FailureData::xmax, and xmax_infomask_changed().
Referenced by heapam_tuple_delete(), and simple_heap_delete().
◆ heap_endscan()
| void heap_endscan | ( | TableScanDesc | sscan | ) |
Definition at line 1322 of file heapam.c.
1323{
1325
1326 /* Note: no locking manipulations needed */
1327
1328 /*
1329 * unpin scan buffers
1330 */
1333
1334 /*
1335 * Must free the read stream before freeing the BufferAccessStrategy.
1336 */
1339
1340 /*
1341 * decrement relation reference count and free scan descriptor storage
1342 */
1344
1347
1350
1353
1356
1357 pfree(scan);
1358}
void RelationDecrementReferenceCount(Relation rel)
Definition: relcache.c:2200
References BufferIsValid(), FreeAccessStrategy(), pfree(), read_stream_end(), RelationDecrementReferenceCount(), ReleaseBuffer(), HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, TableScanDescData::rs_flags, TableScanDescData::rs_key, HeapScanDescData::rs_parallelworkerdata, TableScanDescData::rs_rd, HeapScanDescData::rs_read_stream, TableScanDescData::rs_snapshot, HeapScanDescData::rs_strategy, SO_TEMP_SNAPSHOT, and UnregisterSnapshot().
◆ heap_fetch()
| bool heap_fetch | ( | Relation | relation, |
| Snapshot | snapshot, | ||
| HeapTuple | tuple, | ||
| Buffer * | userbuf, | ||
| bool | keep_buf | ||
| ) |
Definition at line 1620 of file heapam.c.
1625{
1627 ItemId lp;
1628 Buffer buffer;
1629 Page page;
1630 OffsetNumber offnum;
1631 bool valid;
1632
1633 /*
1634 * Fetch and pin the appropriate page of the relation.
1635 */
1637
1638 /*
1639 * Need share lock on buffer to examine tuple commit status.
1640 */
1642 page = BufferGetPage(buffer);
1643
1644 /*
1645 * We'd better check for out-of-range offnum in case of VACUUM since the
1646 * TID was obtained.
1647 */
1648 offnum = ItemPointerGetOffsetNumber(tid);
1650 {
1652 ReleaseBuffer(buffer);
1653 *userbuf = InvalidBuffer;
1654 tuple->t_data = NULL;
1655 return false;
1656 }
1657
1658 /*
1659 * get the item line pointer corresponding to the requested tid
1660 */
1661 lp = PageGetItemId(page, offnum);
1662
1663 /*
1664 * Must check for deleted tuple.
1665 */
1667 {
1669 ReleaseBuffer(buffer);
1670 *userbuf = InvalidBuffer;
1671 tuple->t_data = NULL;
1672 return false;
1673 }
1674
1675 /*
1676 * fill in *tuple fields
1677 */
1681
1682 /*
1683 * check tuple visibility, then release lock
1684 */
1685 valid = HeapTupleSatisfiesVisibility(tuple, snapshot, buffer);
1686
1687 if (valid)
1690
1691 HeapCheckForSerializableConflictOut(valid, relation, tuple, buffer, snapshot);
1692
1694
1695 if (valid)
1696 {
1697 /*
1698 * All checks passed, so return the tuple as valid. Caller is now
1699 * responsible for releasing the buffer.
1700 */
1701 *userbuf = buffer;
1702
1703 return true;
1704 }
1705
1706 /* Tuple failed time qual, but maybe caller wants to see it anyway. */
1707 if (keep_buf)
1708 *userbuf = buffer;
1709 else
1710 {
1711 ReleaseBuffer(buffer);
1712 *userbuf = InvalidBuffer;
1713 tuple->t_data = NULL;
1714 }
1715
1716 return false;
1717}
static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)
Definition: bufpage.h:371
void HeapCheckForSerializableConflictOut(bool visible, Relation relation, HeapTuple tuple, Buffer buffer, Snapshot snapshot)
Definition: heapam.c:9271
static TransactionId HeapTupleHeaderGetXmin(const HeapTupleHeaderData *tup)
Definition: htup_details.h:324
void PredicateLockTID(Relation relation, const ItemPointerData *tid, Snapshot snapshot, TransactionId tuple_xid)
Definition: predicate.c:2621
References BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderGetXmin(), HeapTupleSatisfiesVisibility(), InvalidBuffer, ItemIdGetLength, ItemIdIsNormal, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PredicateLockTID(), ReadBuffer(), RelationGetRelid, ReleaseBuffer(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.
Referenced by heap_lock_updated_tuple_rec(), heapam_fetch_row_version(), and heapam_tuple_lock().
◆ heap_fetch_next_buffer()
|
inlinestatic |
Definition at line 658 of file heapam.c.
659{
661
662 /* release previous scan buffer, if any */
664 {
667 }
668
669 /*
670 * Be sure to check for interrupts at least once per page. Checks at
671 * higher code levels won't be able to stop a seqscan that encounters many
672 * pages' worth of consecutive dead tuples.
673 */
674 CHECK_FOR_INTERRUPTS();
675
676 /*
677 * If the scan direction is changing, reset the prefetch block to the
678 * current block. Otherwise, we will incorrectly prefetch the blocks
679 * between the prefetch block and the current block again before
680 * prefetching blocks in the new, correct scan direction.
681 */
683 {
686 }
687
688 scan->rs_dir = dir;
689
693}
Buffer read_stream_next_buffer(ReadStream *stream, void **per_buffer_data)
Definition: read_stream.c:791
References Assert(), BufferGetBlockNumber(), BufferIsValid(), CHECK_FOR_INTERRUPTS, InvalidBuffer, read_stream_next_buffer(), read_stream_reset(), ReleaseBuffer(), HeapScanDescData::rs_cblock, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_dir, HeapScanDescData::rs_prefetch_block, HeapScanDescData::rs_read_stream, and unlikely.
Referenced by heapgettup(), and heapgettup_pagemode().
◆ heap_finish_speculative()
| void heap_finish_speculative | ( | Relation | relation, |
| const ItemPointerData * | tid | ||
| ) |
Definition at line 6114 of file heapam.c.
6115{
6116 Buffer buffer;
6117 Page page;
6118 OffsetNumber offnum;
6119 ItemId lp = NULL;
6120 HeapTupleHeader htup;
6121
6124 page = BufferGetPage(buffer);
6125
6126 offnum = ItemPointerGetOffsetNumber(tid);
6128 lp = PageGetItemId(page, offnum);
6129
6132
6134
6135 /* NO EREPORT(ERROR) from here till changes are logged */
6136 START_CRIT_SECTION();
6137
6139
6140 MarkBufferDirty(buffer);
6141
6142 /*
6143 * Replace the speculative insertion token with a real t_ctid, pointing to
6144 * itself like it does on regular tuples.
6145 */
6146 htup->t_ctid = *tid;
6147
6148 /* XLOG stuff */
6150 {
6151 xl_heap_confirm xlrec;
6152 XLogRecPtr recptr;
6153
6155
6156 XLogBeginInsert();
6157
6158 /* We want the same filtering on this as on a plain insert */
6160
6163
6165
6166 PageSetLSN(page, recptr);
6167 }
6168
6169 END_CRIT_SECTION();
6170
6171 UnlockReleaseBuffer(buffer);
6172}
Definition: htup_details.h:154
Definition: heapam_xlog.h:427
References Assert(), BUFFER_LOCK_EXCLUSIVE, BufferGetPage(), elog, END_CRIT_SECTION, ERROR, HeapTupleHeaderIsSpeculative(), ItemIdIsNormal, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), MarkBufferDirty(), xl_heap_confirm::offnum, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageSetLSN(), ReadBuffer(), REGBUF_STANDARD, RelationNeedsWAL, SizeOfHeapConfirm, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, UnlockReleaseBuffer(), XLOG_HEAP_CONFIRM, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), and XLogSetRecordFlags().
Referenced by heapam_tuple_complete_speculative().
◆ heap_freeze_prepared_tuples()
| void heap_freeze_prepared_tuples | ( | Buffer | buffer, |
| HeapTupleFreeze * | tuples, | ||
| int | ntuples | ||
| ) |
Definition at line 7406 of file heapam.c.
7407{
7409
7411 {
7414 HeapTupleHeader htup;
7415
7417 heap_execute_freeze_tuple(htup, frz);
7418 }
7419}
static void heap_execute_freeze_tuple(HeapTupleHeader tuple, HeapTupleFreeze *frz)
Definition: heapam.h:475
Definition: heapam.h:142
References BufferGetPage(), heap_execute_freeze_tuple(), i, HeapTupleFreeze::offset, PageGetItem(), and PageGetItemId().
Referenced by heap_page_prune_and_freeze().
◆ heap_freeze_tuple()
| bool heap_freeze_tuple | ( | HeapTupleHeader | tuple, |
| TransactionId | relfrozenxid, | ||
| TransactionId | relminmxid, | ||
| TransactionId | FreezeLimit, | ||
| TransactionId | MultiXactCutoff | ||
| ) |
Definition at line 7428 of file heapam.c.
7431{
7432 HeapTupleFreeze frz;
7433 bool do_freeze;
7434 bool totally_frozen;
7436 HeapPageFreeze pagefrz;
7437
7438 cutoffs.relfrozenxid = relfrozenxid;
7439 cutoffs.relminmxid = relminmxid;
7440 cutoffs.OldestXmin = FreezeLimit;
7441 cutoffs.OldestMxact = MultiXactCutoff;
7442 cutoffs.FreezeLimit = FreezeLimit;
7443 cutoffs.MultiXactCutoff = MultiXactCutoff;
7444
7445 pagefrz.freeze_required = true;
7446 pagefrz.FreezePageRelfrozenXid = FreezeLimit;
7447 pagefrz.FreezePageRelminMxid = MultiXactCutoff;
7448 pagefrz.NoFreezePageRelfrozenXid = FreezeLimit;
7449 pagefrz.NoFreezePageRelminMxid = MultiXactCutoff;
7450
7451 do_freeze = heap_prepare_freeze_tuple(tuple, &cutoffs,
7452 &pagefrz, &frz, &totally_frozen);
7453
7454 /*
7455 * Note that because this is not a WAL-logged operation, we don't need to
7456 * fill in the offset in the freeze record.
7457 */
7458
7459 if (do_freeze)
7460 heap_execute_freeze_tuple(tuple, &frz);
7461 return do_freeze;
7462}
bool heap_prepare_freeze_tuple(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen)
Definition: heapam.c:7080
Definition: heapam.h:180
Definition: vacuum.h:259
References VacuumCutoffs::FreezeLimit, heap_execute_freeze_tuple(), heap_prepare_freeze_tuple(), VacuumCutoffs::MultiXactCutoff, VacuumCutoffs::OldestMxact, VacuumCutoffs::OldestXmin, VacuumCutoffs::relfrozenxid, and VacuumCutoffs::relminmxid.
Referenced by rewrite_heap_tuple().
◆ heap_get_latest_tid()
| void heap_get_latest_tid | ( | TableScanDesc | sscan, |
| ItemPointer | tid | ||
| ) |
Definition at line 1892 of file heapam.c.
1894{
1897 ItemPointerData ctid;
1898 TransactionId priorXmax;
1899
1900 /*
1901 * table_tuple_get_latest_tid() verified that the passed in tid is valid.
1902 * Assume that t_ctid links are valid however - there shouldn't be invalid
1903 * ones in the table.
1904 */
1906
1907 /*
1908 * Loop to chase down t_ctid links. At top of loop, ctid is the tuple we
1909 * need to examine, and *tid is the TID we will return if ctid turns out
1910 * to be bogus.
1911 *
1912 * Note that we will loop until we reach the end of the t_ctid chain.
1913 * Depending on the snapshot passed, there might be at most one visible
1914 * version of the row, but we don't try to optimize for that.
1915 */
1916 ctid = *tid;
1918 for (;;)
1919 {
1920 Buffer buffer;
1921 Page page;
1922 OffsetNumber offnum;
1923 ItemId lp;
1924 HeapTupleData tp;
1925 bool valid;
1926
1927 /*
1928 * Read, pin, and lock the page.
1929 */
1932 page = BufferGetPage(buffer);
1933
1934 /*
1935 * Check for bogus item number. This is not treated as an error
1936 * condition because it can happen while following a t_ctid link. We
1937 * just assume that the prior tid is OK and return it unchanged.
1938 */
1939 offnum = ItemPointerGetOffsetNumber(&ctid);
1941 {
1942 UnlockReleaseBuffer(buffer);
1943 break;
1944 }
1945 lp = PageGetItemId(page, offnum);
1947 {
1948 UnlockReleaseBuffer(buffer);
1949 break;
1950 }
1951
1952 /* OK to access the tuple */
1953 tp.t_self = ctid;
1957
1958 /*
1959 * After following a t_ctid link, we might arrive at an unrelated
1960 * tuple. Check for XMIN match.
1961 */
1964 {
1965 UnlockReleaseBuffer(buffer);
1966 break;
1967 }
1968
1969 /*
1970 * Check tuple visibility; if visible, set it as the new result
1971 * candidate.
1972 */
1973 valid = HeapTupleSatisfiesVisibility(&tp, snapshot, buffer);
1974 HeapCheckForSerializableConflictOut(valid, relation, &tp, buffer, snapshot);
1975 if (valid)
1976 *tid = ctid;
1977
1978 /*
1979 * If there's a valid t_ctid link, follow it, else we're done.
1980 */
1985 {
1986 UnlockReleaseBuffer(buffer);
1987 break;
1988 }
1989
1992 UnlockReleaseBuffer(buffer);
1993 } /* end of loop */
1994}
static bool HeapTupleHeaderIndicatesMovedPartitions(const HeapTupleHeaderData *tup)
Definition: htup_details.h:480
Definition: rel.h:56
Definition: snapshot.h:139
References Assert(), BUFFER_LOCK_SHARE, BufferGetPage(), HEAP_XMAX_INVALID, HeapCheckForSerializableConflictOut(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderIndicatesMovedPartitions(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesVisibility(), InvalidTransactionId, ItemIdGetLength, ItemIdIsNormal, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), ReadBuffer(), RelationGetRelid, TableScanDescData::rs_rd, TableScanDescData::rs_snapshot, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdEquals, TransactionIdIsValid, and UnlockReleaseBuffer().
◆ heap_getnext()
| HeapTuple heap_getnext | ( | TableScanDesc | sscan, |
| ScanDirection | direction | ||
| ) |
Definition at line 1361 of file heapam.c.
1362{
1364
1365 /*
1366 * This is still widely used directly, without going through table AM, so
1367 * add a safety check. It's possible we should, at a later point,
1368 * downgrade this to an assert. The reason for checking the AM routine,
1369 * rather than the AM oid, is that this allows to write regression tests
1370 * that create another AM reusing the heap handler.
1371 */
1374 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1376
1377 /*
1378 * We don't expect direct calls to heap_getnext with valid CheckXidAlive
1379 * for catalog or regular tables. See detailed comments in xact.c where
1380 * these variables are declared. Normally we have such a check at tableam
1381 * level API but this is called from many places so we need to ensure it
1382 * here.
1383 */
1386
1387 /* Note: no locking manipulations needed */
1388
1390 heapgettup_pagemode(scan, direction,
1392 else
1393 heapgettup(scan, direction,
1395
1397 return NULL;
1398
1399 /*
1400 * if we get here it means we have a new current scan tuple, so point to
1401 * the proper return buffer and return the tuple.
1402 */
1403
1405
1407}
static void heapgettup(HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
Definition: heapam.c:911
static void heapgettup_pagemode(HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
Definition: heapam.c:1021
const TableAmRoutine * GetHeapamTableAmRoutine(void)
Definition: heapam_handler.c:2676
References bsysscan, CheckXidAlive, elog, ereport, errcode(), errmsg_internal(), ERROR, GetHeapamTableAmRoutine(), heapgettup(), heapgettup_pagemode(), pgstat_count_heap_getnext, RelationData::rd_tableam, HeapScanDescData::rs_base, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_nkeys, TableScanDescData::rs_rd, SO_ALLOW_PAGEMODE, HeapTupleData::t_data, TransactionIdIsValid, and unlikely.
Referenced by AlterTableMoveAll(), AlterTableSpaceOptions(), check_db_file_conflict(), CreateDatabaseUsingFileCopy(), do_autovacuum(), DropSetting(), DropTableSpace(), find_typed_table_dependencies(), get_all_vacuum_rels(), get_database_list(), get_subscription_list(), get_tables_to_cluster(), get_tablespace_name(), get_tablespace_oid(), GetAllPublicationRelations(), getRelationsInNamespace(), GetSchemaPublicationRelations(), heapam_index_build_range_scan(), heapam_index_validate_scan(), objectsInSchemaToOids(), pgrowlocks(), pgstat_heap(), populate_typ_list(), ReindexMultipleTables(), remove_dbtablespaces(), RemoveSubscriptionRel(), RenameTableSpace(), ThereIsAtLeastOneRole(), and vac_truncate_clog().
◆ heap_getnextslot()
| bool heap_getnextslot | ( | TableScanDesc | sscan, |
| ScanDirection | direction, | ||
| TupleTableSlot * | slot | ||
| ) |
Definition at line 1410 of file heapam.c.
1411{
1413
1414 /* Note: no locking manipulations needed */
1415
1418 else
1420
1422 {
1423 ExecClearTuple(slot);
1424 return false;
1425 }
1426
1427 /*
1428 * if we get here it means we have a new current scan tuple, so point to
1429 * the proper return buffer and return the tuple.
1430 */
1431
1433
1435 scan->rs_cbuf);
1436 return true;
1437}
TupleTableSlot * ExecStoreBufferHeapTuple(HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
Definition: execTuples.c:1581
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:457
References ExecClearTuple(), ExecStoreBufferHeapTuple(), heapgettup(), heapgettup_pagemode(), pgstat_count_heap_getnext, HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_nkeys, TableScanDescData::rs_rd, SO_ALLOW_PAGEMODE, and HeapTupleData::t_data.
◆ heap_getnextslot_tidrange()
| bool heap_getnextslot_tidrange | ( | TableScanDesc | sscan, |
| ScanDirection | direction, | ||
| TupleTableSlot * | slot | ||
| ) |
Definition at line 1513 of file heapam.c.
1515{
1519
1520 /* Note: no locking manipulations needed */
1521 for (;;)
1522 {
1525 else
1527
1529 {
1530 ExecClearTuple(slot);
1531 return false;
1532 }
1533
1534 /*
1535 * heap_set_tidrange will have used heap_setscanlimits to limit the
1536 * range of pages we scan to only ones that can contain the TID range
1537 * we're scanning for. Here we must filter out any tuples from these
1538 * pages that are outside of that range.
1539 */
1541 {
1542 ExecClearTuple(slot);
1543
1544 /*
1545 * When scanning backwards, the TIDs will be in descending order.
1546 * Future tuples in this direction will be lower still, so we can
1547 * just return false to indicate there will be no more tuples.
1548 */
1550 return false;
1551
1552 continue;
1553 }
1554
1555 /*
1556 * Likewise for the final page, we must filter out TIDs greater than
1557 * maxtid.
1558 */
1560 {
1561 ExecClearTuple(slot);
1562
1563 /*
1564 * When scanning forward, the TIDs will be in ascending order.
1565 * Future tuples in this direction will be higher still, so we can
1566 * just return false to indicate there will be no more tuples.
1567 */
1569 return false;
1570 continue;
1571 }
1572
1573 break;
1574 }
1575
1576 /*
1577 * if we get here it means we have a new current scan tuple, so point to
1578 * the proper return buffer and return the tuple.
1579 */
1581
1583 return true;
1584}
int32 ItemPointerCompare(const ItemPointerData *arg1, const ItemPointerData *arg2)
Definition: itemptr.c:51
struct TableScanDescData::@50::@51 tidrange
References ExecClearTuple(), ExecStoreBufferHeapTuple(), heapgettup(), heapgettup_pagemode(), ItemPointerCompare(), pgstat_count_heap_getnext, HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_maxtid, TableScanDescData::rs_mintid, TableScanDescData::rs_nkeys, TableScanDescData::rs_rd, ScanDirectionIsBackward, ScanDirectionIsForward, SO_ALLOW_PAGEMODE, TableScanDescData::st, HeapTupleData::t_data, HeapTupleData::t_self, and TableScanDescData::tidrange.
◆ heap_hot_search_buffer()
| bool heap_hot_search_buffer | ( | ItemPointer | tid, |
| Relation | relation, | ||
| Buffer | buffer, | ||
| Snapshot | snapshot, | ||
| HeapTuple | heapTuple, | ||
| bool * | all_dead, | ||
| bool | first_call | ||
| ) |
Definition at line 1740 of file heapam.c.
1743{
1746 BlockNumber blkno;
1747 OffsetNumber offnum;
1748 bool at_chain_start;
1749 bool valid;
1751 GlobalVisState *vistest = NULL;
1752
1753 /* If this is not the first call, previous call returned a (live!) tuple */
1754 if (all_dead)
1755 *all_dead = first_call;
1756
1757 blkno = ItemPointerGetBlockNumber(tid);
1758 offnum = ItemPointerGetOffsetNumber(tid);
1759 at_chain_start = first_call;
1760 skip = !first_call;
1761
1762 /* XXX: we should assert that a snapshot is pushed or registered */
1765
1766 /* Scan through possible multiple members of HOT-chain */
1767 for (;;)
1768 {
1769 ItemId lp;
1770
1771 /* check for bogus TID */
1773 break;
1774
1775 lp = PageGetItemId(page, offnum);
1776
1777 /* check for unused, dead, or redirected items */
1779 {
1780 /* We should only see a redirect at start of chain */
1782 {
1783 /* Follow the redirect */
1784 offnum = ItemIdGetRedirect(lp);
1785 at_chain_start = false;
1786 continue;
1787 }
1788 /* else must be end of chain */
1789 break;
1790 }
1791
1792 /*
1793 * Update heapTuple to point to the element of the HOT chain we're
1794 * currently investigating. Having t_self set correctly is important
1795 * because the SSI checks and the *Satisfies routine for historical
1796 * MVCC snapshots need the correct tid to decide about the visibility.
1797 */
1802
1803 /*
1804 * Shouldn't see a HEAP_ONLY tuple at chain start.
1805 */
1807 break;
1808
1809 /*
1810 * The xmin should match the previous xmax value, else chain is
1811 * broken.
1812 */
1814 !TransactionIdEquals(prev_xmax,
1816 break;
1817
1818 /*
1819 * When first_call is true (and thus, skip is initially false) we'll
1820 * return the first tuple we find. But on later passes, heapTuple
1821 * will initially be pointing to the tuple we returned last time.
1822 * Returning it again would be incorrect (and would loop forever), so
1823 * we skip it and return the next match we find.
1824 */
1826 {
1827 /* If it's visible per the snapshot, we must return it */
1828 valid = HeapTupleSatisfiesVisibility(heapTuple, snapshot, buffer);
1829 HeapCheckForSerializableConflictOut(valid, relation, heapTuple,
1830 buffer, snapshot);
1831
1832 if (valid)
1833 {
1834 ItemPointerSetOffsetNumber(tid, offnum);
1837 if (all_dead)
1838 *all_dead = false;
1839 return true;
1840 }
1841 }
1843
1844 /*
1845 * If we can't see it, maybe no one else can either. At caller
1846 * request, check whether all chain members are dead to all
1847 * transactions.
1848 *
1849 * Note: if you change the criterion here for what is "dead", fix the
1850 * planner's get_actual_variable_range() function to match.
1851 */
1852 if (all_dead && *all_dead)
1853 {
1854 if (!vistest)
1855 vistest = GlobalVisTestFor(relation);
1856
1858 *all_dead = false;
1859 }
1860
1861 /*
1862 * Check to see if HOT chain continues past this tuple; if so fetch
1863 * the next offnum and loop around.
1864 */
1866 {
1868 blkno);
1870 at_chain_start = false;
1872 }
1873 else
1874 break; /* end of chain */
1875 }
1876
1877 return false;
1878}
bool HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
Definition: heapam_visibility.c:1474
static bool HeapTupleIsHotUpdated(const HeapTupleData *tuple)
Definition: htup_details.h:768
static bool HeapTupleIsHeapOnly(const HeapTupleData *tuple)
Definition: htup_details.h:786
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
static void ItemPointerSetOffsetNumber(ItemPointerData *pointer, OffsetNumber offsetNumber)
Definition: itemptr.h:158
Definition: procarray.c:168
References Assert(), BufferGetBlockNumber(), BufferGetPage(), GlobalVisTestFor(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleIsHeapOnly(), HeapTupleIsHotUpdated(), HeapTupleIsSurelyDead(), HeapTupleSatisfiesVisibility(), InvalidTransactionId, ItemIdGetLength, ItemIdGetRedirect, ItemIdIsNormal, ItemIdIsRedirected, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerSet(), ItemPointerSetOffsetNumber(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PredicateLockTID(), RecentXmin, RelationGetRelid, skip, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdEquals, and TransactionIdIsValid.
Referenced by BitmapHeapScanNextBlock(), heap_index_delete_tuples(), and heapam_index_fetch_tuple().
◆ heap_index_delete_tuples()
| TransactionId heap_index_delete_tuples | ( | Relation | rel, |
| TM_IndexDeleteOp * | delstate | ||
| ) |
Definition at line 8144 of file heapam.c.
8145{
8146 /* Initial assumption is that earlier pruning took care of conflict */
8150 Page page = NULL;
8152 TransactionId priorXmax;
8153#ifdef USE_PREFETCH
8154 IndexDeletePrefetchState prefetch_state;
8155 int prefetch_distance;
8156#endif
8157 SnapshotData SnapshotNonVacuumable;
8158 int finalndeltids = 0,
8159 nblocksaccessed = 0;
8160
8161 /* State that's only used in bottom-up index deletion case */
8162 int nblocksfavorable = 0;
8164 lastfreespace = 0,
8165 actualfreespace = 0;
8166 bool bottomup_final_block = false;
8167
8169
8170 /* Sort caller's deltids array by TID for further processing */
8171 index_delete_sort(delstate);
8172
8173 /*
8174 * Bottom-up case: resort deltids array in an order attuned to where the
8175 * greatest number of promising TIDs are to be found, and determine how
8176 * many blocks from the start of sorted array should be considered
8177 * favorable. This will also shrink the deltids array in order to
8178 * eliminate completely unfavorable blocks up front.
8179 */
8181 nblocksfavorable = bottomup_sort_and_shrink(delstate);
8182
8183#ifdef USE_PREFETCH
8184 /* Initialize prefetch state. */
8185 prefetch_state.cur_hblkno = InvalidBlockNumber;
8186 prefetch_state.next_item = 0;
8187 prefetch_state.ndeltids = delstate->ndeltids;
8188 prefetch_state.deltids = delstate->deltids;
8189
8190 /*
8191 * Determine the prefetch distance that we will attempt to maintain.
8192 *
8193 * Since the caller holds a buffer lock somewhere in rel, we'd better make
8194 * sure that isn't a catalog relation before we call code that does
8195 * syscache lookups, to avoid risk of deadlock.
8196 */
8198 prefetch_distance = maintenance_io_concurrency;
8199 else
8200 prefetch_distance =
8202
8203 /* Cap initial prefetch distance for bottom-up deletion caller */
8205 {
8206 Assert(nblocksfavorable >= 1);
8208 prefetch_distance = Min(prefetch_distance, nblocksfavorable);
8209 }
8210
8211 /* Start prefetching. */
8212 index_delete_prefetch_buffer(rel, &prefetch_state, prefetch_distance);
8213#endif
8214
8215 /* Iterate over deltids, determine which to delete, check their horizon */
8218 {
8222 OffsetNumber offnum;
8223
8224 /*
8225 * Read buffer, and perform required extra steps each time a new block
8226 * is encountered. Avoid refetching if it's the same block as the one
8227 * from the last htid.
8228 */
8230 ItemPointerGetBlockNumber(htid) != blkno)
8231 {
8232 /*
8233 * Consider giving up early for bottom-up index deletion caller
8234 * first. (Only prefetch next-next block afterwards, when it
8235 * becomes clear that we're at least going to access the next
8236 * block in line.)
8237 *
8238 * Sometimes the first block frees so much space for bottom-up
8239 * caller that the deletion process can end without accessing any
8240 * more blocks. It is usually necessary to access 2 or 3 blocks
8241 * per bottom-up deletion operation, though.
8242 */
8244 {
8245 /*
8246 * We often allow caller to delete a few additional items
8247 * whose entries we reached after the point that space target
8248 * from caller was satisfied. The cost of accessing the page
8249 * was already paid at that point, so it made sense to finish
8250 * it off. When that happened, we finalize everything here
8251 * (by finishing off the whole bottom-up deletion operation
8252 * without needlessly paying the cost of accessing any more
8253 * blocks).
8254 */
8255 if (bottomup_final_block)
8256 break;
8257
8258 /*
8259 * Give up when we didn't enable our caller to free any
8260 * additional space as a result of processing the page that we
8261 * just finished up with. This rule is the main way in which
8262 * we keep the cost of bottom-up deletion under control.
8263 */
8264 if (nblocksaccessed >= 1 && actualfreespace == lastfreespace)
8265 break;
8266 lastfreespace = actualfreespace; /* for next time */
8267
8268 /*
8269 * Deletion operation (which is bottom-up) will definitely
8270 * access the next block in line. Prepare for that now.
8271 *
8272 * Decay target free space so that we don't hang on for too
8273 * long with a marginal case. (Space target is only truly
8274 * helpful when it allows us to recognize that we don't need
8275 * to access more than 1 or 2 blocks to satisfy caller due to
8276 * agreeable workload characteristics.)
8277 *
8278 * We are a bit more patient when we encounter contiguous
8279 * blocks, though: these are treated as favorable blocks. The
8280 * decay process is only applied when the next block in line
8281 * is not a favorable/contiguous block. This is not an
8282 * exception to the general rule; we still insist on finding
8283 * at least one deletable item per block accessed. See
8284 * bottomup_nblocksfavorable() for full details of the theory
8285 * behind favorable blocks and heap block locality in general.
8286 *
8287 * Note: The first block in line is always treated as a
8288 * favorable block, so the earliest possible point that the
8289 * decay can be applied is just before we access the second
8290 * block in line. The Assert() verifies this for us.
8291 */
8292 Assert(nblocksaccessed > 0 || nblocksfavorable > 0);
8293 if (nblocksfavorable > 0)
8294 nblocksfavorable--;
8295 else
8296 curtargetfreespace /= 2;
8297 }
8298
8299 /* release old buffer */
8302
8303 blkno = ItemPointerGetBlockNumber(htid);
8305 nblocksaccessed++;
8307 nblocksaccessed <= BOTTOMUP_MAX_NBLOCKS);
8308
8309#ifdef USE_PREFETCH
8310
8311 /*
8312 * To maintain the prefetch distance, prefetch one more page for
8313 * each page we read.
8314 */
8315 index_delete_prefetch_buffer(rel, &prefetch_state, 1);
8316#endif
8317
8319
8321 maxoff = PageGetMaxOffsetNumber(page);
8322 }
8323
8324 /*
8325 * In passing, detect index corruption involving an index page with a
8326 * TID that points to a location in the heap that couldn't possibly be
8327 * correct. We only do this with actual TIDs from caller's index page
8328 * (not items reached by traversing through a HOT chain).
8329 */
8330 index_delete_check_htid(delstate, page, maxoff, htid, istatus);
8331
8334 else
8335 {
8336 ItemPointerData tmp = *htid;
8337 HeapTupleData heapTuple;
8338
8339 /* Are any tuples from this HOT chain non-vacuumable? */
8341 &heapTuple, NULL, true))
8342 continue; /* can't delete entry */
8343
8344 /* Caller will delete, since whole HOT chain is vacuumable */
8346
8347 /* Maintain index free space info for bottom-up deletion case */
8349 {
8351 actualfreespace += istatus->freespace;
8352 if (actualfreespace >= curtargetfreespace)
8353 bottomup_final_block = true;
8354 }
8355 }
8356
8357 /*
8358 * Maintain snapshotConflictHorizon value for deletion operation as a
8359 * whole by advancing current value using heap tuple headers. This is
8360 * loosely based on the logic for pruning a HOT chain.
8361 */
8362 offnum = ItemPointerGetOffsetNumber(htid);
8364 for (;;)
8365 {
8366 ItemId lp;
8367 HeapTupleHeader htup;
8368
8369 /* Sanity check (pure paranoia) */
8371 break;
8372
8373 /*
8374 * An offset past the end of page's line pointer array is possible
8375 * when the array was truncated
8376 */
8377 if (offnum > maxoff)
8378 break;
8379
8380 lp = PageGetItemId(page, offnum);
8382 {
8383 offnum = ItemIdGetRedirect(lp);
8384 continue;
8385 }
8386
8387 /*
8388 * We'll often encounter LP_DEAD line pointers (especially with an
8389 * entry marked knowndeletable by our caller up front). No heap
8390 * tuple headers get examined for an htid that leads us to an
8391 * LP_DEAD item. This is okay because the earlier pruning
8392 * operation that made the line pointer LP_DEAD in the first place
8393 * must have considered the original tuple header as part of
8394 * generating its own snapshotConflictHorizon value.
8395 *
8396 * Relying on XLOG_HEAP2_PRUNE_VACUUM_SCAN records like this is
8397 * the same strategy that index vacuuming uses in all cases. Index
8398 * VACUUM WAL records don't even have a snapshotConflictHorizon
8399 * field of their own for this reason.
8400 */
8402 break;
8403
8405
8406 /*
8407 * Check the tuple XMIN against prior XMAX, if any
8408 */
8411 break;
8412
8413 HeapTupleHeaderAdvanceConflictHorizon(htup,
8414 &snapshotConflictHorizon);
8415
8416 /*
8417 * If the tuple is not HOT-updated, then we are at the end of this
8418 * HOT-chain. No need to visit later tuples from the same update
8419 * chain (they get their own index entries) -- just move on to
8420 * next htid from index AM caller.
8421 */
8423 break;
8424
8425 /* Advance to next HOT chain member */
8428 priorXmax = HeapTupleHeaderGetUpdateXid(htup);
8429 }
8430
8431 /* Enable further/final shrinking of deltids for caller */
8432 finalndeltids = i + 1;
8433 }
8434
8436
8437 /*
8438 * Shrink deltids array to exclude non-deletable entries at the end. This
8439 * is not just a minor optimization. Final deltids array size might be
8440 * zero for a bottom-up caller. Index AM is explicitly allowed to rely on
8441 * ndeltids being zero in all cases with zero total deletable entries.
8442 */
8444 delstate->ndeltids = finalndeltids;
8445
8446 return snapshotConflictHorizon;
8447}
static int bottomup_sort_and_shrink(TM_IndexDeleteOp *delstate)
Definition: heapam.c:8701
void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)
Definition: heapam.c:7999
static void index_delete_check_htid(TM_IndexDeleteOp *delstate, Page page, OffsetNumber maxoff, const ItemPointerData *htid, TM_IndexStatus *istatus)
Definition: heapam.c:8084
bool heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, bool *all_dead, bool first_call)
Definition: heapam.c:1740
static bool HeapTupleHeaderIsHotUpdated(const HeapTupleHeaderData *tup)
Definition: htup_details.h:534
#define InitNonVacuumableSnapshot(snapshotdata, vistestp)
Definition: snapmgr.h:50
int get_tablespace_maintenance_io_concurrency(Oid spcid)
Definition: spccache.c:229
References Assert(), TM_IndexDeleteOp::bottomup, BOTTOMUP_MAX_NBLOCKS, bottomup_sort_and_shrink(), TM_IndexDeleteOp::bottomupfreespace, buf, BUFFER_LOCK_SHARE, BufferGetPage(), BufferIsValid(), TM_IndexDeleteOp::deltids, FirstOffsetNumber, TM_IndexStatus::freespace, get_tablespace_maintenance_io_concurrency(), GlobalVisTestFor(), heap_hot_search_buffer(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderIsHotUpdated(), i, TM_IndexDelete::id, index_delete_check_htid(), index_delete_sort(), InitNonVacuumableSnapshot, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, InvalidTransactionId, IsCatalogRelation(), ItemIdGetRedirect, ItemIdIsNormal, ItemIdIsRedirected, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), TM_IndexStatus::knowndeletable, LockBuffer(), maintenance_io_concurrency, Min, TM_IndexDeleteOp::ndeltids, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), TM_IndexStatus::promising, RelationData::rd_rel, ReadBuffer(), TM_IndexDeleteOp::status, HeapTupleHeaderData::t_ctid, TM_IndexDelete::tid, TransactionIdEquals, TransactionIdIsValid, and UnlockReleaseBuffer().
◆ heap_inplace_lock()
| bool heap_inplace_lock | ( | Relation | relation, |
| HeapTuple | oldtup_ptr, | ||
| Buffer | buffer, | ||
| void(*)(void *) | release_callback, | ||
| void * | arg | ||
| ) |
Definition at line 6380 of file heapam.c.
6383{
6385 TM_Result result;
6386 bool ret;
6387
6388#ifdef USE_ASSERT_CHECKING
6390 check_inplace_rel_lock(oldtup_ptr);
6391#endif
6392
6394
6395 /*
6396 * Construct shared cache inval if necessary. Because we pass a tuple
6397 * version without our own inplace changes or inplace changes other
6398 * sessions complete while we wait for locks, inplace update mustn't
6399 * change catcache lookup keys. But we aren't bothering with index
6400 * updates either, so that's true a fortiori. After LockBuffer(), it
6401 * would be too late, because this might reach a
6402 * CatalogCacheInitializeCache() that locks "buffer".
6403 */
6404 CacheInvalidateHeapTupleInplace(relation, oldtup_ptr, NULL);
6405
6408
6409 /*----------
6410 * Interpret HeapTupleSatisfiesUpdate() like heap_update() does, except:
6411 *
6412 * - wait unconditionally
6413 * - already locked tuple above, since inplace needs that unconditionally
6414 * - don't recheck header after wait: simpler to defer to next iteration
6415 * - don't try to continue even if the updater aborts: likewise
6416 * - no crosscheck
6417 */
6419 buffer);
6420
6422 {
6423 /* no known way this can happen */
6425 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
6427 }
6429 {
6430 /*
6431 * CREATE INDEX might reach this if an expression is silly enough to
6432 * call e.g. SELECT ... FROM pg_class FOR SHARE. C code of other SQL
6433 * statements might get here after a heap_update() of the same row, in
6434 * the absence of an intervening CommandCounterIncrement().
6435 */
6437 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
6438 errmsg("tuple to be updated was already modified by an operation triggered by the current command")));
6439 }
6441 {
6442 TransactionId xwait;
6443 uint16 infomask;
6444
6447
6449 {
6452 int remain;
6453
6455 lockmode, NULL))
6456 {
6458 release_callback(arg);
6459 ret = false;
6462 &remain);
6463 }
6464 else
6465 ret = true;
6466 }
6468 ret = true;
6470 ret = true;
6471 else
6472 {
6474 release_callback(arg);
6475 ret = false;
6477 XLTW_Update);
6478 }
6479 }
6480 else
6481 {
6482 ret = (result == TM_Ok);
6483 if (!ret)
6484 {
6486 release_callback(arg);
6487 }
6488 }
6489
6490 /*
6491 * GetCatalogSnapshot() relies on invalidation messages to know when to
6492 * take a new snapshot. COMMIT of xwait is responsible for sending the
6493 * invalidation. We're not acquiring heavyweight locks sufficient to
6494 * block if not yet sent, so we must take a new snapshot to ensure a later
6495 * attempt has a fair chance. While we don't need this if xwait aborted,
6496 * don't bother optimizing that.
6497 */
6498 if (!ret)
6499 {
6501 ForgetInplace_Inval();
6502 InvalidateCatalogSnapshot();
6503 }
6504 return ret;
6505}
void CacheInvalidateHeapTupleInplace(Relation relation, HeapTuple tuple, HeapTuple newtuple)
Definition: inval.c:1588
void UnlockTuple(Relation relation, const ItemPointerData *tid, LOCKMODE lockmode)
Definition: lmgr.c:601
void LockTuple(Relation relation, const ItemPointerData *tid, LOCKMODE lockmode)
Definition: lmgr.c:562
References arg, Assert(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferIsValid(), CacheInvalidateHeapTupleInplace(), DoesMultiXactIdConflict(), ereport, errcode(), errmsg(), errmsg_internal(), ERROR, ForgetInplace_Inval(), GetCurrentCommandId(), HEAP_XMAX_IS_KEYSHR_LOCKED(), HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax(), HeapTupleSatisfiesUpdate(), InplaceUpdateTupleLock, InvalidateCatalogSnapshot(), LockBuffer(), LockTuple(), LockTupleNoKeyExclusive, MultiXactIdWait(), MultiXactStatusNoKeyUpdate, RelationGetRelid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleData::t_self, TM_BeingModified, TM_Invisible, TM_Ok, TM_SelfModified, TransactionIdIsCurrentTransactionId(), UnlockTuple(), XactLockTableWait(), and XLTW_Update.
Referenced by systable_inplace_update_begin().
◆ heap_inplace_unlock()
Definition at line 6669 of file heapam.c.
References BUFFER_LOCK_UNLOCK, ForgetInplace_Inval(), InplaceUpdateTupleLock, LockBuffer(), HeapTupleData::t_self, and UnlockTuple().
Referenced by systable_inplace_update_cancel().
◆ heap_inplace_update_and_unlock()
| void heap_inplace_update_and_unlock | ( | Relation | relation, |
| HeapTuple | oldtup, | ||
| HeapTuple | tuple, | ||
| Buffer | buffer | ||
| ) |
Definition at line 6516 of file heapam.c.
6519{
6521 uint32 oldlen;
6522 uint32 newlen;
6523 char *dst;
6524 char *src;
6525 int nmsgs = 0;
6526 SharedInvalidationMessage *invalMessages = NULL;
6527 bool RelcacheInitFileInval = false;
6528
6534
6537
6538 /* Like RecordTransactionCommit(), log only if needed */
6540 nmsgs = inplaceGetInvalidationMessages(&invalMessages,
6541 &RelcacheInitFileInval);
6542
6543 /*
6544 * Unlink relcache init files as needed. If unlinking, acquire
6545 * RelCacheInitLock until after associated invalidations. By doing this
6546 * in advance, if we checkpoint and then crash between inplace
6547 * XLogInsert() and inval, we don't rely on StartupXLOG() ->
6548 * RelationCacheInitFileRemove(). That uses elevel==LOG, so replay would
6549 * neglect to PANIC on EIO.
6550 */
6551 PreInplace_Inval();
6552
6553 /*----------
6554 * NO EREPORT(ERROR) from here till changes are complete
6555 *
6556 * Our buffer lock won't stop a reader having already pinned and checked
6557 * visibility for this tuple. Hence, we write WAL first, then mutate the
6558 * buffer. Like in MarkBufferDirtyHint() or RecordTransactionCommit(),
6559 * checkpoint delay makes that acceptable. With the usual order of
6560 * changes, a crash after memcpy() and before XLogInsert() could allow
6561 * datfrozenxid to overtake relfrozenxid:
6562 *
6563 * ["D" is a VACUUM (ONLY_DATABASE_STATS)]
6564 * ["R" is a VACUUM tbl]
6565 * D: vac_update_datfrozenxid() -> systable_beginscan(pg_class)
6566 * D: systable_getnext() returns pg_class tuple of tbl
6567 * R: memcpy() into pg_class tuple of tbl
6568 * D: raise pg_database.datfrozenxid, XLogInsert(), finish
6569 * [crash]
6570 * [recovery restores datfrozenxid w/o relfrozenxid]
6571 *
6572 * Mimic MarkBufferDirtyHint() subroutine XLogSaveBufferForHint().
6573 * Specifically, use DELAY_CHKPT_START, and copy the buffer to the stack.
6574 * The stack copy facilitates a FPI of the post-mutation block before we
6575 * accept other sessions seeing it. DELAY_CHKPT_START allows us to
6576 * XLogInsert() before MarkBufferDirty(). Since XLogSaveBufferForHint()
6577 * can operate under BUFFER_LOCK_SHARED, it can't avoid DELAY_CHKPT_START.
6578 * This function, however, likely could avoid it with the following order
6579 * of operations: MarkBufferDirty(), XLogInsert(), memcpy(). Opt to use
6580 * DELAY_CHKPT_START here, too, as a way to have fewer distinct code
6581 * patterns to analyze. Inplace update isn't so frequent that it should
6582 * pursue the small optimization of skipping DELAY_CHKPT_START.
6583 */
6585 START_CRIT_SECTION();
6587
6588 /* XLOG stuff */
6590 {
6591 xl_heap_inplace xlrec;
6592 PGAlignedBlock copied_buffer;
6597 uintptr_t dst_offset_in_block;
6598 RelFileLocator rlocator;
6599 ForkNumber forkno;
6600 BlockNumber blkno;
6601 XLogRecPtr recptr;
6602
6606 xlrec.relcacheInitFileInval = RelcacheInitFileInval;
6607 xlrec.nmsgs = nmsgs;
6608
6609 XLogBeginInsert();
6611 if (nmsgs != 0)
6612 XLogRegisterData(invalMessages,
6614
6615 /* register block matching what buffer will look like after changes */
6618 dst_offset_in_block = dst - origdata;
6619 memcpy(copied_buffer.data + dst_offset_in_block, src, newlen);
6620 BufferGetTag(buffer, &rlocator, &forkno, &blkno);
6623 REGBUF_STANDARD);
6624 XLogRegisterBufData(0, src, newlen);
6625
6626 /* inplace updates aren't decoded atm, don't log the origin */
6627
6629
6630 PageSetLSN(page, recptr);
6631 }
6632
6633 memcpy(dst, src, newlen);
6634
6635 MarkBufferDirty(buffer);
6636
6638
6639 /*
6640 * Send invalidations to shared queue. SearchSysCacheLocked1() assumes we
6641 * do this before UnlockTuple().
6642 *
6643 * If we're mutating a tuple visible only to this transaction, there's an
6644 * equivalent transactional inval from the action that created the tuple,
6645 * and this inval is superfluous.
6646 */
6647 AtInplace_Inval();
6648
6650 END_CRIT_SECTION();
6652
6654
6655 /*
6656 * Queue a transactional inval. The immediate invalidation we just sent
6657 * is the only one known to be necessary. To reduce risk from the
6658 * transition to immediate invalidation, continue sending a transactional
6659 * invalidation like we've long done. Third-party code might rely on it.
6660 */
6662 CacheInvalidateHeapTuple(relation, tuple, NULL);
6663}
void BufferGetTag(Buffer buffer, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum)
Definition: bufmgr.c:4244
int inplaceGetInvalidationMessages(SharedInvalidationMessage **msgs, bool *RelcacheInitFileInval)
Definition: inval.c:1088
Definition: c.h:1118
Definition: relfilelocator.h:59
Definition: heapam_xlog.h:435
void XLogRegisterBufData(uint8 block_id, const void *data, uint32 len)
Definition: xloginsert.c:409
void XLogRegisterBlock(uint8 block_id, RelFileLocator *rlocator, ForkNumber forknum, BlockNumber blknum, const PageData *page, uint8 flags)
Definition: xloginsert.c:313
References AcceptInvalidationMessages(), Assert(), AtInplace_Inval(), BUFFER_LOCK_UNLOCK, BufferGetBlock(), BufferGetPage(), BufferGetTag(), CacheInvalidateHeapTuple(), PGAlignedBlock::data, xl_heap_inplace::dbId, DELAY_CHKPT_START, PGPROC::delayChkptFlags, elog, END_CRIT_SECTION, ERROR, inplaceGetInvalidationMessages(), InplaceUpdateTupleLock, IsBootstrapProcessingMode, ItemPointerEquals(), ItemPointerGetOffsetNumber(), LockBuffer(), lower(), MAIN_FORKNUM, MarkBufferDirty(), MinSizeOfHeapInplace, MyDatabaseId, MyDatabaseTableSpace, MyProc, xl_heap_inplace::nmsgs, xl_heap_inplace::offnum, PageSetLSN(), PreInplace_Inval(), REGBUF_STANDARD, RelationNeedsWAL, xl_heap_inplace::relcacheInitFileInval, START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, HeapTupleData::t_len, HeapTupleData::t_self, xl_heap_inplace::tsId, UnlockTuple(), upper(), XLOG_HEAP_INPLACE, XLogBeginInsert(), XLogInsert(), XLogRegisterBlock(), XLogRegisterBufData(), XLogRegisterData(), and XLogStandbyInfoActive.
Referenced by systable_inplace_update_finish().
◆ heap_insert()
| void heap_insert | ( | Relation | relation, |
| HeapTuple | tup, | ||
| CommandId | cid, | ||
| int | options, | ||
| BulkInsertState | bistate | ||
| ) |
Definition at line 2103 of file heapam.c.
2105{
2107 HeapTuple heaptup;
2108 Buffer buffer;
2110 bool all_visible_cleared = false;
2111
2112 /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
2114 RelationGetNumberOfAttributes(relation));
2115
2116 AssertHasSnapshotForToast(relation);
2117
2118 /*
2119 * Fill in tuple header fields and toast the tuple if necessary.
2120 *
2121 * Note: below this point, heaptup is the data we actually intend to store
2122 * into the relation; tup is the caller's original untoasted data.
2123 */
2125
2126 /*
2127 * Find buffer to insert this tuple into. If the page is all visible,
2128 * this will also pin the requisite visibility map page.
2129 */
2132 &vmbuffer, NULL,
2133 0);
2134
2135 /*
2136 * We're about to do the actual insert -- but check for conflict first, to
2137 * avoid possibly having to roll back work we've just done.
2138 *
2139 * This is safe without a recheck as long as there is no possibility of
2140 * another process scanning the page between this check and the insert
2141 * being visible to the scan (i.e., an exclusive buffer content lock is
2142 * continuously held from this point until the tuple insert is visible).
2143 *
2144 * For a heap insert, we only need to check for table-level SSI locks. Our
2145 * new tuple can't possibly conflict with existing tuple locks, and heap
2146 * page locks are only consolidated versions of tuple locks; they do not
2147 * lock "gaps" as index page locks do. So we don't need to specify a
2148 * buffer when making the call, which makes for a faster check.
2149 */
2151
2152 /* NO EREPORT(ERROR) from here till changes are logged */
2153 START_CRIT_SECTION();
2154
2155 RelationPutHeapTuple(relation, buffer, heaptup,
2157
2159 {
2160 all_visible_cleared = true;
2162 visibilitymap_clear(relation,
2164 vmbuffer, VISIBILITYMAP_VALID_BITS);
2165 }
2166
2167 /*
2168 * XXX Should we set PageSetPrunable on this page ?
2169 *
2170 * The inserting transaction may eventually abort thus making this tuple
2171 * DEAD and hence available for pruning. Though we don't want to optimize
2172 * for aborts, if no other tuple in this page is UPDATEd/DELETEd, the
2173 * aborted tuple will never be pruned until next vacuum is triggered.
2174 *
2175 * If you do add PageSetPrunable here, add it in heap_xlog_insert too.
2176 */
2177
2178 MarkBufferDirty(buffer);
2179
2180 /* XLOG stuff */
2182 {
2183 xl_heap_insert xlrec;
2184 xl_heap_header xlhdr;
2185 XLogRecPtr recptr;
2188 int bufflags = 0;
2189
2190 /*
2191 * If this is a catalog, we need to transmit combo CIDs to properly
2192 * decode, so log that as well.
2193 */
2195 log_heap_new_cid(relation, heaptup);
2196
2197 /*
2198 * If this is the single and first tuple on page, we can reinit the
2199 * page instead of restoring the whole thing. Set flag, and hide
2200 * buffer references from XLogInsert.
2201 */
2204 {
2205 info |= XLOG_HEAP_INIT_PAGE;
2206 bufflags |= REGBUF_WILL_INIT;
2207 }
2208
2210 xlrec.flags = 0;
2211 if (all_visible_cleared)
2216
2217 /*
2218 * For logical decoding, we need the tuple even if we're doing a full
2219 * page write, so make sure it's included even if we take a full-page
2220 * image. (XXX We could alternatively store a pointer into the FPW).
2221 */
2224 {
2226 bufflags |= REGBUF_KEEP_DATA;
2227
2230 }
2231
2232 XLogBeginInsert();
2234
2238
2239 /*
2240 * note we mark xlhdr as belonging to buffer; if XLogInsert decides to
2241 * write the whole page to the xlog, we don't need to store
2242 * xl_heap_header in the xlog.
2243 */
2246 /* PG73FORMAT: write bitmap [+ padding] [+ oid] + data */
2247 XLogRegisterBufData(0,
2250
2251 /* filtering by origin on a row level is much more efficient */
2253
2254 recptr = XLogInsert(RM_HEAP_ID, info);
2255
2256 PageSetLSN(page, recptr);
2257 }
2258
2259 END_CRIT_SECTION();
2260
2261 UnlockReleaseBuffer(buffer);
2263 ReleaseBuffer(vmbuffer);
2264
2265 /*
2266 * If tuple is cacheable, mark it for invalidation from the caches in case
2267 * we abort. Note it is OK to do this after releasing the buffer, because
2268 * the heaptup data structure is all in local memory, not in the shared
2269 * buffer.
2270 */
2271 CacheInvalidateHeapTuple(relation, heaptup, NULL);
2272
2273 /* Note: speculative insertions are counted too, even if aborted later */
2274 pgstat_count_heap_insert(relation, 1);
2275
2276 /*
2277 * If heaptup is a private copy, release it. Don't forget to copy t_self
2278 * back to the caller's image, too.
2279 */
2280 if (heaptup != tup)
2281 {
2283 heap_freetuple(heaptup);
2284 }
2285}
static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid, CommandId cid, int options)
Definition: heapam.c:2294
void RelationPutHeapTuple(Relation relation, Buffer buffer, HeapTuple tuple, bool token)
Definition: hio.c:35
Buffer RelationGetBufferForTuple(Relation relation, Size len, Buffer otherBuffer, int options, BulkInsertState bistate, Buffer *vmbuffer, Buffer *vmbuffer_other, int num_pages)
Definition: hio.c:500
void pgstat_count_heap_insert(Relation rel, PgStat_Counter n)
Definition: pgstat_relation.c:374
Definition: oid2name.c:30
Definition: heapam_xlog.h:161
References Assert(), AssertHasSnapshotForToast(), BufferGetBlockNumber(), BufferGetPage(), CacheInvalidateHeapTuple(), CheckForSerializableConflictIn(), END_CRIT_SECTION, FirstOffsetNumber, xl_heap_insert::flags, GetCurrentTransactionId(), heap_freetuple(), HEAP_INSERT_NO_LOGICAL, HEAP_INSERT_SPECULATIVE, heap_prepare_insert(), HeapTupleHeaderGetNatts, InvalidBlockNumber, InvalidBuffer, IsToastRelation(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), log_heap_new_cid(), MarkBufferDirty(), xl_heap_insert::offnum, PageClearAllVisible(), PageGetMaxOffsetNumber(), PageIsAllVisible(), PageSetLSN(), pgstat_count_heap_insert(), REGBUF_KEEP_DATA, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetBufferForTuple(), RelationGetNumberOfAttributes, RelationIsAccessibleInLogicalDecoding, RelationIsLogicallyLogged, RelationNeedsWAL, RelationPutHeapTuple(), ReleaseBuffer(), SizeOfHeapHeader, SizeOfHeapInsert, SizeofHeapTupleHeader, START_CRIT_SECTION, HeapTupleData::t_data, xl_heap_header::t_hoff, HeapTupleHeaderData::t_hoff, xl_heap_header::t_infomask, HeapTupleHeaderData::t_infomask, xl_heap_header::t_infomask2, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, UnlockReleaseBuffer(), visibilitymap_clear(), VISIBILITYMAP_VALID_BITS, XLH_INSERT_ALL_VISIBLE_CLEARED, XLH_INSERT_CONTAINS_NEW_TUPLE, XLH_INSERT_IS_SPECULATIVE, XLH_INSERT_ON_TOAST_RELATION, XLOG_HEAP_INIT_PAGE, XLOG_HEAP_INSERT, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), XLogRegisterData(), and XLogSetRecordFlags().
Referenced by heapam_tuple_insert(), heapam_tuple_insert_speculative(), simple_heap_insert(), and toast_save_datum().
◆ heap_lock_tuple()
| TM_Result heap_lock_tuple | ( | Relation | relation, |
| HeapTuple | tuple, | ||
| CommandId | cid, | ||
| LockTupleMode | mode, | ||
| LockWaitPolicy | wait_policy, | ||
| bool | follow_updates, | ||
| Buffer * | buffer, | ||
| TM_FailureData * | tmfd | ||
| ) |
Definition at line 4605 of file heapam.c.
4609{
4610 TM_Result result;
4612 ItemId lp;
4613 Page page;
4615 BlockNumber block;
4616 TransactionId xid,
4617 xmax;
4618 uint16 old_infomask,
4619 new_infomask,
4620 new_infomask2;
4621 bool first_time = true;
4622 bool skip_tuple_lock = false;
4623 bool have_tuple_lock = false;
4624 bool cleared_all_frozen = false;
4625
4627 block = ItemPointerGetBlockNumber(tid);
4628
4629 /*
4630 * Before locking the buffer, pin the visibility map page if it appears to
4631 * be necessary. Since we haven't got the lock yet, someone else might be
4632 * in the middle of changing this, so we'll need to recheck after we have
4633 * the lock.
4634 */
4636 visibilitymap_pin(relation, block, &vmbuffer);
4637
4639
4640 page = BufferGetPage(*buffer);
4643
4647
4648l3:
4649 result = HeapTupleSatisfiesUpdate(tuple, cid, *buffer);
4650
4652 {
4653 /*
4654 * This is possible, but only when locking a tuple for ON CONFLICT
4655 * UPDATE. We return this value here rather than throwing an error in
4656 * order to give that case the opportunity to throw a more specific
4657 * error.
4658 */
4659 result = TM_Invisible;
4660 goto out_locked;
4661 }
4663 result == TM_Updated ||
4664 result == TM_Deleted)
4665 {
4666 TransactionId xwait;
4667 uint16 infomask;
4668 uint16 infomask2;
4669 bool require_sleep;
4670 ItemPointerData t_ctid;
4671
4672 /* must copy state data before unlocking buffer */
4677
4679
4680 /*
4681 * If any subtransaction of the current top transaction already holds
4682 * a lock as strong as or stronger than what we're requesting, we
4683 * effectively hold the desired lock already. We *must* succeed
4684 * without trying to take the tuple lock, else we will deadlock
4685 * against anyone wanting to acquire a stronger lock.
4686 *
4687 * Note we only do this the first time we loop on the HTSU result;
4688 * there is no point in testing in subsequent passes, because
4689 * evidently our own transaction cannot have acquired a new lock after
4690 * the first time we checked.
4691 */
4692 if (first_time)
4693 {
4694 first_time = false;
4695
4697 {
4699 int nmembers;
4700 MultiXactMember *members;
4701
4702 /*
4703 * We don't need to allow old multixacts here; if that had
4704 * been the case, HeapTupleSatisfiesUpdate would have returned
4705 * MayBeUpdated and we wouldn't be here.
4706 */
4707 nmembers =
4709 HEAP_XMAX_IS_LOCKED_ONLY(infomask));
4710
4712 {
4713 /* only consider members of our own transaction */
4715 continue;
4716
4718 {
4719 pfree(members);
4720 result = TM_Ok;
4721 goto out_unlocked;
4722 }
4723 else
4724 {
4725 /*
4726 * Disable acquisition of the heavyweight tuple lock.
4727 * Otherwise, when promoting a weaker lock, we might
4728 * deadlock with another locker that has acquired the
4729 * heavyweight tuple lock and is waiting for our
4730 * transaction to finish.
4731 *
4732 * Note that in this case we still need to wait for
4733 * the multixact if required, to avoid acquiring
4734 * conflicting locks.
4735 */
4736 skip_tuple_lock = true;
4737 }
4738 }
4739
4740 if (members)
4741 pfree(members);
4742 }
4744 {
4746 {
4749 HEAP_XMAX_IS_SHR_LOCKED(infomask) ||
4750 HEAP_XMAX_IS_EXCL_LOCKED(infomask));
4751 result = TM_Ok;
4752 goto out_unlocked;
4755 HEAP_XMAX_IS_EXCL_LOCKED(infomask))
4756 {
4757 result = TM_Ok;
4758 goto out_unlocked;
4759 }
4760 break;
4763 {
4764 result = TM_Ok;
4765 goto out_unlocked;
4766 }
4767 break;
4770 infomask2 & HEAP_KEYS_UPDATED)
4771 {
4772 result = TM_Ok;
4773 goto out_unlocked;
4774 }
4775 break;
4776 }
4777 }
4778 }
4779
4780 /*
4781 * Initially assume that we will have to wait for the locking
4782 * transaction(s) to finish. We check various cases below in which
4783 * this can be turned off.
4784 */
4785 require_sleep = true;
4787 {
4788 /*
4789 * If we're requesting KeyShare, and there's no update present, we
4790 * don't need to wait. Even if there is an update, we can still
4791 * continue if the key hasn't been modified.
4792 *
4793 * However, if there are updates, we need to walk the update chain
4794 * to mark future versions of the row as locked, too. That way,
4795 * if somebody deletes that future version, we're protected
4796 * against the key going away. This locking of future versions
4797 * could block momentarily, if a concurrent transaction is
4798 * deleting a key; or it could return a value to the effect that
4799 * the transaction deleting the key has already committed. So we
4800 * do this before re-locking the buffer; otherwise this would be
4801 * prone to deadlocks.
4802 *
4803 * Note that the TID we're locking was grabbed before we unlocked
4804 * the buffer. For it to change while we're not looking, the
4805 * other properties we're testing for below after re-locking the
4806 * buffer would also change, in which case we would restart this
4807 * loop above.
4808 */
4810 {
4811 bool updated;
4812
4813 updated = !HEAP_XMAX_IS_LOCKED_ONLY(infomask);
4814
4815 /*
4816 * If there are updates, follow the update chain; bail out if
4817 * that cannot be done.
4818 */
4819 if (follow_updates && updated)
4820 {
4821 TM_Result res;
4822
4823 res = heap_lock_updated_tuple(relation, tuple, &t_ctid,
4824 GetCurrentTransactionId(),
4825 mode);
4827 {
4828 result = res;
4829 /* recovery code expects to have buffer lock held */
4831 goto failed;
4832 }
4833 }
4834
4836
4837 /*
4838 * Make sure it's still an appropriate lock, else start over.
4839 * Also, if it wasn't updated before we released the lock, but
4840 * is updated now, we start over too; the reason is that we
4841 * now need to follow the update chain to lock the new
4842 * versions.
4843 */
4846 !updated))
4847 goto l3;
4848
4849 /* Things look okay, so we can skip sleeping */
4850 require_sleep = false;
4851
4852 /*
4853 * Note we allow Xmax to change here; other updaters/lockers
4854 * could have modified it before we grabbed the buffer lock.
4855 * However, this is not a problem, because with the recheck we
4856 * just did we ensure that they still don't conflict with the
4857 * lock we want.
4858 */
4859 }
4860 }
4862 {
4863 /*
4864 * If we're requesting Share, we can similarly avoid sleeping if
4865 * there's no update and no exclusive lock present.
4866 */
4868 !HEAP_XMAX_IS_EXCL_LOCKED(infomask))
4869 {
4871
4872 /*
4873 * Make sure it's still an appropriate lock, else start over.
4874 * See above about allowing xmax to change.
4875 */
4878 goto l3;
4879 require_sleep = false;
4880 }
4881 }
4883 {
4884 /*
4885 * If we're requesting NoKeyExclusive, we might also be able to
4886 * avoid sleeping; just ensure that there no conflicting lock
4887 * already acquired.
4888 */
4890 {
4892 mode, NULL))
4893 {
4894 /*
4895 * No conflict, but if the xmax changed under us in the
4896 * meantime, start over.
4897 */
4901 xwait))
4902 goto l3;
4903
4904 /* otherwise, we're good */
4905 require_sleep = false;
4906 }
4907 }
4909 {
4911
4912 /* if the xmax changed in the meantime, start over */
4915 xwait))
4916 goto l3;
4917 /* otherwise, we're good */
4918 require_sleep = false;
4919 }
4920 }
4921
4922 /*
4923 * As a check independent from those above, we can also avoid sleeping
4924 * if the current transaction is the sole locker of the tuple. Note
4925 * that the strength of the lock already held is irrelevant; this is
4926 * not about recording the lock in Xmax (which will be done regardless
4927 * of this optimization, below). Also, note that the cases where we
4928 * hold a lock stronger than we are requesting are already handled
4929 * above by not doing anything.
4930 *
4931 * Note we only deal with the non-multixact case here; MultiXactIdWait
4932 * is well equipped to deal with this situation on its own.
4933 */
4935 TransactionIdIsCurrentTransactionId(xwait))
4936 {
4937 /* ... but if the xmax changed in the meantime, start over */
4941 xwait))
4942 goto l3;
4944 require_sleep = false;
4945 }
4946
4947 /*
4948 * Time to sleep on the other transaction/multixact, if necessary.
4949 *
4950 * If the other transaction is an update/delete that's already
4951 * committed, then sleeping cannot possibly do any good: if we're
4952 * required to sleep, get out to raise an error instead.
4953 *
4954 * By here, we either have already acquired the buffer exclusive lock,
4955 * or we must wait for the locking transaction or multixact; so below
4956 * we ensure that we grab buffer lock after the sleep.
4957 */
4959 {
4961 goto failed;
4962 }
4963 else if (require_sleep)
4964 {
4965 /*
4966 * Acquire tuple lock to establish our priority for the tuple, or
4967 * die trying. LockTuple will release us when we are next-in-line
4968 * for the tuple. We must do this even if we are share-locking,
4969 * but not if we already have a weaker lock on the tuple.
4970 *
4971 * If we are forced to "start over" below, we keep the tuple lock;
4972 * this arranges that we stay at the head of the line while
4973 * rechecking tuple state.
4974 */
4975 if (!skip_tuple_lock &&
4977 &have_tuple_lock))
4978 {
4979 /*
4980 * This can only happen if wait_policy is Skip and the lock
4981 * couldn't be obtained.
4982 */
4983 result = TM_WouldBlock;
4984 /* recovery code expects to have buffer lock held */
4986 goto failed;
4987 }
4988
4990 {
4992
4993 /* We only ever lock tuples, never update them */
4996
4997 /* wait for multixact to end, or die trying */
4998 switch (wait_policy)
4999 {
5003 break;
5006 status, infomask, relation,
5007 NULL, false))
5008 {
5009 result = TM_WouldBlock;
5010 /* recovery code expects to have buffer lock held */
5012 goto failed;
5013 }
5014 break;
5017 status, infomask, relation,
5018 NULL, log_lock_failures))
5020 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
5022 RelationGetRelationName(relation))));
5023
5024 break;
5025 }
5026
5027 /*
5028 * Of course, the multixact might not be done here: if we're
5029 * requesting a light lock mode, other transactions with light
5030 * locks could still be alive, as well as locks owned by our
5031 * own xact or other subxacts of this backend. We need to
5032 * preserve the surviving MultiXact members. Note that it
5033 * isn't absolutely necessary in the latter case, but doing so
5034 * is simpler.
5035 */
5036 }
5037 else
5038 {
5039 /* wait for regular transaction to end, or die trying */
5040 switch (wait_policy)
5041 {
5044 XLTW_Lock);
5045 break;
5048 {
5049 result = TM_WouldBlock;
5050 /* recovery code expects to have buffer lock held */
5052 goto failed;
5053 }
5054 break;
5058 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
5060 RelationGetRelationName(relation))));
5061 break;
5062 }
5063 }
5064
5065 /* if there are updates, follow the update chain */
5067 {
5068 TM_Result res;
5069
5070 res = heap_lock_updated_tuple(relation, tuple, &t_ctid,
5071 GetCurrentTransactionId(),
5072 mode);
5074 {
5075 result = res;
5076 /* recovery code expects to have buffer lock held */
5078 goto failed;
5079 }
5080 }
5081
5083
5084 /*
5085 * xwait is done, but if xwait had just locked the tuple then some
5086 * other xact could update this tuple before we get to this point.
5087 * Check for xmax change, and start over if so.
5088 */
5091 xwait))
5092 goto l3;
5093
5095 {
5096 /*
5097 * Otherwise check if it committed or aborted. Note we cannot
5098 * be here if the tuple was only locked by somebody who didn't
5099 * conflict with us; that would have been handled above. So
5100 * that transaction must necessarily be gone by now. But
5101 * don't check for this in the multixact case, because some
5102 * locker transactions might still be running.
5103 */
5105 }
5106 }
5107
5108 /* By here, we're certain that we hold buffer exclusive lock again */
5109
5110 /*
5111 * We may lock if previous xmax aborted, or if it committed but only
5112 * locked the tuple without updating it; or if we didn't have to wait
5113 * at all for whatever reason.
5114 */
5115 if (!require_sleep ||
5119 result = TM_Ok;
5121 result = TM_Updated;
5122 else
5123 result = TM_Deleted;
5124 }
5125
5126failed:
5128 {
5131
5132 /*
5133 * When locking a tuple under LockWaitSkip semantics and we fail with
5134 * TM_WouldBlock above, it's possible for concurrent transactions to
5135 * release the lock and set HEAP_XMAX_INVALID in the meantime. So
5136 * this assert is slightly different from the equivalent one in
5137 * heap_delete and heap_update.
5138 */
5147 else
5149 goto out_locked;
5150 }
5151
5152 /*
5153 * If we didn't pin the visibility map page and the page has become all
5154 * visible while we were busy locking the buffer, or during some
5155 * subsequent window during which we had it unlocked, we'll have to unlock
5156 * and re-lock, to avoid holding the buffer lock across I/O. That's a bit
5157 * unfortunate, especially since we'll now have to recheck whether the
5158 * tuple has been locked or updated under us, but hopefully it won't
5159 * happen very often.
5160 */
5162 {
5164 visibilitymap_pin(relation, block, &vmbuffer);
5166 goto l3;
5167 }
5168
5171
5172 /*
5173 * If this is the first possibly-multixact-able operation in the current
5174 * transaction, set my per-backend OldestMemberMXactId setting. We can be
5175 * certain that the transaction will never become a member of any older
5176 * MultiXactIds than that. (We have to do this even if we end up just
5177 * using our own TransactionId below, since some other backend could
5178 * incorporate our XID into a MultiXact immediately afterwards.)
5179 */
5180 MultiXactIdSetOldestMember();
5181
5182 /*
5183 * Compute the new xmax and infomask to store into the tuple. Note we do
5184 * not modify the tuple just yet, because that would leave it in the wrong
5185 * state if multixact.c elogs.
5186 */
5189 &xid, &new_infomask, &new_infomask2);
5190
5191 START_CRIT_SECTION();
5192
5193 /*
5194 * Store transaction information of xact locking the tuple.
5195 *
5196 * Note: Cmax is meaningless in this context, so don't set it; this avoids
5197 * possibly generating a useless combo CID. Moreover, if we're locking a
5198 * previously updated tuple, it's important to preserve the Cmax.
5199 *
5200 * Also reset the HOT UPDATE bit, but only if there's no update; otherwise
5201 * we would break the HOT chain.
5202 */
5210
5211 /*
5212 * Make sure there is no forward chain link in t_ctid. Note that in the
5213 * cases where the tuple has been updated, we must not overwrite t_ctid,
5214 * because it was set by the updater. Moreover, if the tuple has been
5215 * updated, we need to follow the update chain to lock the new versions of
5216 * the tuple as well.
5217 */
5220
5221 /* Clear only the all-frozen bit on visibility map if needed */
5223 visibilitymap_clear(relation, block, vmbuffer,
5224 VISIBILITYMAP_ALL_FROZEN))
5225 cleared_all_frozen = true;
5226
5227
5228 MarkBufferDirty(*buffer);
5229
5230 /*
5231 * XLOG stuff. You might think that we don't need an XLOG record because
5232 * there is no state change worth restoring after a crash. You would be
5233 * wrong however: we have just written either a TransactionId or a
5234 * MultiXactId that may never have been seen on disk before, and we need
5235 * to make sure that there are XLOG entries covering those ID numbers.
5236 * Else the same IDs might be re-used after a crash, which would be
5237 * disastrous if this page made it to disk before the crash. Essentially
5238 * we have to enforce the WAL log-before-data rule even in this case.
5239 * (Also, in a PITR log-shipping or 2PC environment, we have to have XLOG
5240 * entries for everything anyway.)
5241 */
5243 {
5244 xl_heap_lock xlrec;
5245 XLogRecPtr recptr;
5246
5247 XLogBeginInsert();
5249
5251 xlrec.xmax = xid;
5256
5257 /* we don't decode row locks atm, so no need to log the origin */
5258
5260
5261 PageSetLSN(page, recptr);
5262 }
5263
5264 END_CRIT_SECTION();
5265
5266 result = TM_Ok;
5267
5268out_locked:
5270
5271out_unlocked:
5273 ReleaseBuffer(vmbuffer);
5274
5275 /*
5276 * Don't update the visibility map here. Locking a tuple doesn't change
5277 * visibility info.
5278 */
5279
5280 /*
5281 * Now that we have successfully marked the tuple as locked, we can
5282 * release the lmgr tuple lock, if we had it.
5283 */
5284 if (have_tuple_lock)
5286
5287 return result;
5288}
static bool ConditionalMultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, Relation rel, int *remaining, bool logLockFailure)
Definition: heapam.c:7821
static TM_Result heap_lock_updated_tuple(Relation rel, HeapTuple tuple, const ItemPointerData *ctid, TransactionId xid, LockTupleMode mode)
Definition: heapam.c:6069
static void ItemPointerCopy(const ItemPointerData *fromPointer, ItemPointerData *toPointer)
Definition: itemptr.h:172
Definition: heapam_xlog.h:405
References Assert(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetPage(), BufferIsValid(), TM_FailureData::cmax, compute_infobits(), compute_new_xmax_infomask(), ConditionalMultiXactIdWait(), ConditionalXactLockTableWait(), TM_FailureData::ctid, DoesMultiXactIdConflict(), elog, END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, xl_heap_lock::flags, get_mxact_status_for_lock(), GetCurrentTransactionId(), GetMultiXactIdMembers(), heap_acquire_tuplock(), HEAP_KEYS_UPDATED, heap_lock_updated_tuple(), HEAP_XMAX_INVALID, HEAP_XMAX_IS_EXCL_LOCKED(), HEAP_XMAX_IS_KEYSHR_LOCKED(), HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMAX_IS_SHR_LOCKED(), HeapTupleHeaderClearHotUpdated(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderIsOnlyLocked(), HeapTupleHeaderSetXmax(), HeapTupleSatisfiesUpdate(), i, xl_heap_lock::infobits_set, InvalidBuffer, InvalidCommandId, ItemIdGetLength, ItemIdIsNormal, ItemPointerCopy(), ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), LockTupleExclusive, LockTupleKeyShare, LockTupleNoKeyExclusive, LockTupleShare, LockWaitBlock, LockWaitError, LockWaitSkip, log_lock_failures, MarkBufferDirty(), mode, MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusNoKeyUpdate, xl_heap_lock::offnum, PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetLSN(), pfree(), ReadBuffer(), REGBUF_STANDARD, RelationGetRelationName, RelationGetRelid, RelationNeedsWAL, ReleaseBuffer(), SizeOfHeapLock, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TM_BeingModified, TM_Deleted, TM_Invisible, TM_Ok, TM_SelfModified, TM_Updated, TM_WouldBlock, TransactionIdEquals, TransactionIdIsCurrentTransactionId(), TUPLOCK_from_mxstatus, UnlockTupleTuplock, UpdateXmaxHintBits(), VISIBILITYMAP_ALL_FROZEN, visibilitymap_clear(), visibilitymap_pin(), XactLockTableWait(), XLH_LOCK_ALL_FROZEN_CLEARED, XLOG_HEAP_LOCK, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), XLTW_Lock, xl_heap_lock::xmax, TM_FailureData::xmax, and xmax_infomask_changed().
Referenced by heapam_tuple_lock().
◆ heap_lock_updated_tuple()
|
static |
Definition at line 6069 of file heapam.c.
6071{
6072 /*
6073 * If the tuple has not been updated, or has moved into another partition
6074 * (effectively a delete) stop here.
6075 */
6078 {
6079 /*
6080 * If this is the first possibly-multixact-able operation in the
6081 * current transaction, set my per-backend OldestMemberMXactId
6082 * setting. We can be certain that the transaction will never become a
6083 * member of any older MultiXactIds than that. (We have to do this
6084 * even if we end up just using our own TransactionId below, since
6085 * some other backend could incorporate our XID into a MultiXact
6086 * immediately afterwards.)
6087 */
6088 MultiXactIdSetOldestMember();
6089
6091 }
6092
6093 /* nothing to lock */
6095}
static TM_Result heap_lock_updated_tuple_rec(Relation rel, const ItemPointerData *tid, TransactionId xid, LockTupleMode mode)
Definition: heapam.c:5724
References heap_lock_updated_tuple_rec(), HeapTupleHeaderIndicatesMovedPartitions(), ItemPointerEquals(), mode, MultiXactIdSetOldestMember(), HeapTupleData::t_data, HeapTupleData::t_self, and TM_Ok.
Referenced by heap_lock_tuple().
◆ heap_lock_updated_tuple_rec()
|
static |
Definition at line 5724 of file heapam.c.
5726{
5727 TM_Result result;
5728 ItemPointerData tupid;
5729 HeapTupleData mytup;
5731 uint16 new_infomask,
5732 new_infomask2,
5733 old_infomask,
5734 old_infomask2;
5735 TransactionId xmax,
5736 new_xmax;
5738 bool cleared_all_frozen = false;
5739 bool pinned_desired_page;
5741 BlockNumber block;
5742
5743 ItemPointerCopy(tid, &tupid);
5744
5745 for (;;)
5746 {
5747 new_infomask = 0;
5748 new_xmax = InvalidTransactionId;
5749 block = ItemPointerGetBlockNumber(&tupid);
5751
5753 {
5754 /*
5755 * if we fail to find the updated version of the tuple, it's
5756 * because it was vacuumed/pruned away after its creator
5757 * transaction aborted. So behave as if we got to the end of the
5758 * chain, and there's no further tuple to lock: return success to
5759 * caller.
5760 */
5761 result = TM_Ok;
5762 goto out_unlocked;
5763 }
5764
5765l4:
5766 CHECK_FOR_INTERRUPTS();
5767
5768 /*
5769 * Before locking the buffer, pin the visibility map page if it
5770 * appears to be necessary. Since we haven't got the lock yet,
5771 * someone else might be in the middle of changing this, so we'll need
5772 * to recheck after we have the lock.
5773 */
5775 {
5776 visibilitymap_pin(rel, block, &vmbuffer);
5777 pinned_desired_page = true;
5778 }
5779 else
5780 pinned_desired_page = false;
5781
5783
5784 /*
5785 * If we didn't pin the visibility map page and the page has become
5786 * all visible while we were busy locking the buffer, we'll have to
5787 * unlock and re-lock, to avoid holding the buffer lock across I/O.
5788 * That's a bit unfortunate, but hopefully shouldn't happen often.
5789 *
5790 * Note: in some paths through this function, we will reach here
5791 * holding a pin on a vm page that may or may not be the one matching
5792 * this page. If this page isn't all-visible, we won't use the vm
5793 * page, but we hold onto such a pin till the end of the function.
5794 */
5796 {
5798 visibilitymap_pin(rel, block, &vmbuffer);
5800 }
5801
5802 /*
5803 * Check the tuple XMIN against prior XMAX, if any. If we reached the
5804 * end of the chain, we're done, so return success.
5805 */
5808 priorXmax))
5809 {
5810 result = TM_Ok;
5811 goto out_locked;
5812 }
5813
5814 /*
5815 * Also check Xmin: if this tuple was created by an aborted
5816 * (sub)transaction, then we already locked the last live one in the
5817 * chain, thus we're done, so return success.
5818 */
5820 {
5821 result = TM_Ok;
5822 goto out_locked;
5823 }
5824
5828
5829 /*
5830 * If this tuple version has been updated or locked by some concurrent
5831 * transaction(s), what we do depends on whether our lock mode
5832 * conflicts with what those other transactions hold, and also on the
5833 * status of them.
5834 */
5836 {
5837 TransactionId rawxmax;
5838 bool needwait;
5839
5842 {
5843 int nmembers;
5845 MultiXactMember *members;
5846
5847 /*
5848 * We don't need a test for pg_upgrade'd tuples: this is only
5849 * applied to tuples after the first in an update chain. Said
5850 * first tuple in the chain may well be locked-in-9.2-and-
5851 * pg_upgraded, but that one was already locked by our caller,
5852 * not us; and any subsequent ones cannot be because our
5853 * caller must necessarily have obtained a snapshot later than
5854 * the pg_upgrade itself.
5855 */
5857
5859 HEAP_XMAX_IS_LOCKED_ONLY(old_infomask));
5861 {
5863 members[i].xid,
5864 mode,
5865 &mytup,
5866 &needwait);
5867
5868 /*
5869 * If the tuple was already locked by ourselves in a
5870 * previous iteration of this (say heap_lock_tuple was
5871 * forced to restart the locking loop because of a change
5872 * in xmax), then we hold the lock already on this tuple
5873 * version and we don't need to do anything; and this is
5874 * not an error condition either. We just need to skip
5875 * this tuple and continue locking the next version in the
5876 * update chain.
5877 */
5879 {
5880 pfree(members);
5882 }
5883
5884 if (needwait)
5885 {
5888 &mytup.t_self,
5889 XLTW_LockUpdated);
5890 pfree(members);
5891 goto l4;
5892 }
5894 {
5895 pfree(members);
5896 goto out_locked;
5897 }
5898 }
5899 if (members)
5900 pfree(members);
5901 }
5902 else
5903 {
5904 MultiXactStatus status;
5905
5906 /*
5907 * For a non-multi Xmax, we first need to compute the
5908 * corresponding MultiXactStatus by using the infomask bits.
5909 */
5911 {
5913 status = MultiXactStatusForKeyShare;
5915 status = MultiXactStatusForShare;
5917 {
5919 status = MultiXactStatusForUpdate;
5920 else
5921 status = MultiXactStatusForNoKeyUpdate;
5922 }
5923 else
5924 {
5925 /*
5926 * LOCK_ONLY present alone (a pg_upgraded tuple marked
5927 * as share-locked in the old cluster) shouldn't be
5928 * seen in the middle of an update chain.
5929 */
5931 }
5932 }
5933 else
5934 {
5935 /* it's an update, but which kind? */
5937 status = MultiXactStatusUpdate;
5938 else
5939 status = MultiXactStatusNoKeyUpdate;
5940 }
5941
5943 &mytup, &needwait);
5944
5945 /*
5946 * If the tuple was already locked by ourselves in a previous
5947 * iteration of this (say heap_lock_tuple was forced to
5948 * restart the locking loop because of a change in xmax), then
5949 * we hold the lock already on this tuple version and we don't
5950 * need to do anything; and this is not an error condition
5951 * either. We just need to skip this tuple and continue
5952 * locking the next version in the update chain.
5953 */
5956
5957 if (needwait)
5958 {
5961 XLTW_LockUpdated);
5962 goto l4;
5963 }
5965 {
5966 goto out_locked;
5967 }
5968 }
5969 }
5970
5971 /* compute the new Xmax and infomask values for the tuple ... */
5974 &new_xmax, &new_infomask, &new_infomask2);
5975
5977 visibilitymap_clear(rel, block, vmbuffer,
5978 VISIBILITYMAP_ALL_FROZEN))
5979 cleared_all_frozen = true;
5980
5981 START_CRIT_SECTION();
5982
5983 /* ... and set them */
5989
5991
5992 /* XLOG stuff */
5994 {
5995 xl_heap_lock_updated xlrec;
5996 XLogRecPtr recptr;
5998
5999 XLogBeginInsert();
6001
6003 xlrec.xmax = new_xmax;
6005 xlrec.flags =
6006 cleared_all_frozen ? XLH_LOCK_ALL_FROZEN_CLEARED : 0;
6007
6009
6011
6012 PageSetLSN(page, recptr);
6013 }
6014
6015 END_CRIT_SECTION();
6016
6017next:
6018 /* if we find the end of update chain, we're done. */
6023 {
6024 result = TM_Ok;
6025 goto out_locked;
6026 }
6027
6028 /* tail recursion */
6032 }
6033
6034 result = TM_Ok;
6035
6036out_locked:
6038
6039out_unlocked:
6041 ReleaseBuffer(vmbuffer);
6042
6043 return result;
6044}
bool heap_fetch(Relation relation, Snapshot snapshot, HeapTuple tuple, Buffer *userbuf, bool keep_buf)
Definition: heapam.c:1620
static TM_Result test_lockmode_for_conflict(MultiXactStatus status, TransactionId xid, LockTupleMode mode, HeapTuple tup, bool *needwait)
Definition: heapam.c:5633
Definition: heapam_xlog.h:416
References Assert(), buf, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetPage(), CHECK_FOR_INTERRUPTS, compute_infobits(), compute_new_xmax_infomask(), elog, END_CRIT_SECTION, ERROR, xl_heap_lock_updated::flags, GetMultiXactIdMembers(), heap_fetch(), HEAP_KEYS_UPDATED, HEAP_LOCKED_UPGRADED(), HEAP_XMAX_INVALID, HEAP_XMAX_IS_EXCL_LOCKED(), HEAP_XMAX_IS_KEYSHR_LOCKED(), HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMAX_IS_SHR_LOCKED(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderIndicatesMovedPartitions(), HeapTupleHeaderIsOnlyLocked(), HeapTupleHeaderSetXmax(), i, xl_heap_lock_updated::infobits_set, InvalidBuffer, InvalidTransactionId, ItemPointerCopy(), ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), MarkBufferDirty(), mode, MultiXactStatusForKeyShare, MultiXactStatusForNoKeyUpdate, MultiXactStatusForShare, MultiXactStatusForUpdate, MultiXactStatusNoKeyUpdate, MultiXactStatusUpdate, next, xl_heap_lock_updated::offnum, PageIsAllVisible(), PageSetLSN(), pfree(), REGBUF_STANDARD, RelationNeedsWAL, ReleaseBuffer(), SizeOfHeapLockUpdated, SnapshotAny, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_self, test_lockmode_for_conflict(), TM_Ok, TM_SelfModified, TransactionIdDidAbort(), TransactionIdEquals, TransactionIdIsValid, UnlockReleaseBuffer(), VISIBILITYMAP_ALL_FROZEN, visibilitymap_clear(), visibilitymap_pin(), XactLockTableWait(), XLH_LOCK_ALL_FROZEN_CLEARED, XLOG_HEAP2_LOCK_UPDATED, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), XLTW_LockUpdated, and xl_heap_lock_updated::xmax.
Referenced by heap_lock_updated_tuple().
◆ heap_multi_insert()
| void heap_multi_insert | ( | Relation | relation, |
| TupleTableSlot ** | slots, | ||
| int | ntuples, | ||
| CommandId | cid, | ||
| int | options, | ||
| BulkInsertState | bistate | ||
| ) |
Definition at line 2374 of file heapam.c.
2376{
2378 HeapTuple *heaptuples;
2380 int ndone;
2381 PGAlignedBlock scratch;
2382 Page page;
2384 bool needwal;
2385 Size saveFreeSpace;
2388 bool starting_with_empty_page = false;
2389 int npages = 0;
2390 int npages_used = 0;
2391
2392 /* currently not needed (thus unsupported) for heap_multi_insert() */
2394
2395 AssertHasSnapshotForToast(relation);
2396
2397 needwal = RelationNeedsWAL(relation);
2398 saveFreeSpace = RelationGetTargetPageFreeSpace(relation,
2399 HEAP_DEFAULT_FILLFACTOR);
2400
2401 /* Toast and set header data in all the slots */
2404 {
2405 HeapTuple tuple;
2406
2411 options);
2412 }
2413
2414 /*
2415 * We're about to do the actual inserts -- but check for conflict first,
2416 * to minimize the possibility of having to roll back work we've just
2417 * done.
2418 *
2419 * A check here does not definitively prevent a serialization anomaly;
2420 * that check MUST be done at least past the point of acquiring an
2421 * exclusive buffer content lock on every buffer that will be affected,
2422 * and MAY be done after all inserts are reflected in the buffers and
2423 * those locks are released; otherwise there is a race condition. Since
2424 * multiple buffers can be locked and unlocked in the loop below, and it
2425 * would not be feasible to identify and lock all of those buffers before
2426 * the loop, we must do a final check at the end.
2427 *
2428 * The check here could be omitted with no loss of correctness; it is
2429 * present strictly as an optimization.
2430 *
2431 * For heap inserts, we only need to check for table-level SSI locks. Our
2432 * new tuples can't possibly conflict with existing tuple locks, and heap
2433 * page locks are only consolidated versions of tuple locks; they do not
2434 * lock "gaps" as index page locks do. So we don't need to specify a
2435 * buffer when making the call, which makes for a faster check.
2436 */
2438
2439 ndone = 0;
2440 while (ndone < ntuples)
2441 {
2442 Buffer buffer;
2443 bool all_visible_cleared = false;
2444 bool all_frozen_set = false;
2445 int nthispage;
2446
2447 CHECK_FOR_INTERRUPTS();
2448
2449 /*
2450 * Compute number of pages needed to fit the to-be-inserted tuples in
2451 * the worst case. This will be used to determine how much to extend
2452 * the relation by in RelationGetBufferForTuple(), if needed. If we
2453 * filled a prior page from scratch, we can just update our last
2454 * computation, but if we started with a partially filled page,
2455 * recompute from scratch, the number of potentially required pages
2456 * can vary due to tuples needing to fit onto the page, page headers
2457 * etc.
2458 */
2459 if (ndone == 0 || !starting_with_empty_page)
2460 {
2461 npages = heap_multi_insert_pages(heaptuples, ndone, ntuples,
2462 saveFreeSpace);
2463 npages_used = 0;
2464 }
2465 else
2466 npages_used++;
2467
2468 /*
2469 * Find buffer where at least the next tuple will fit. If the page is
2470 * all-visible, this will also pin the requisite visibility map page.
2471 *
2472 * Also pin visibility map page if COPY FREEZE inserts tuples into an
2473 * empty page. See all_frozen_set below.
2474 */
2475 buffer = RelationGetBufferForTuple(relation, heaptuples[ndone]->t_len,
2477 &vmbuffer, NULL,
2478 npages - npages_used);
2479 page = BufferGetPage(buffer);
2480
2481 starting_with_empty_page = PageGetMaxOffsetNumber(page) == 0;
2482
2484 {
2485 all_frozen_set = true;
2486 /* Lock the vmbuffer before entering the critical section */
2488 }
2489
2490 /* NO EREPORT(ERROR) from here till changes are logged */
2491 START_CRIT_SECTION();
2492
2493 /*
2494 * RelationGetBufferForTuple has ensured that the first tuple fits.
2495 * Put that on the page, and then as many other tuples as fit.
2496 */
2498
2499 /*
2500 * For logical decoding we need combo CIDs to properly decode the
2501 * catalog.
2502 */
2503 if (needwal && need_cids)
2504 log_heap_new_cid(relation, heaptuples[ndone]);
2505
2506 for (nthispage = 1; ndone + nthispage < ntuples; nthispage++)
2507 {
2508 HeapTuple heaptup = heaptuples[ndone + nthispage];
2509
2511 break;
2512
2514
2515 /*
2516 * For logical decoding we need combo CIDs to properly decode the
2517 * catalog.
2518 */
2519 if (needwal && need_cids)
2520 log_heap_new_cid(relation, heaptup);
2521 }
2522
2523 /*
2524 * If the page is all visible, need to clear that, unless we're only
2525 * going to add further frozen rows to it.
2526 *
2527 * If we're only adding already frozen rows to a previously empty
2528 * page, mark it as all-frozen and update the visibility map. We're
2529 * already holding a pin on the vmbuffer.
2530 */
2532 {
2533 all_visible_cleared = true;
2534 PageClearAllVisible(page);
2535 visibilitymap_clear(relation,
2536 BufferGetBlockNumber(buffer),
2537 vmbuffer, VISIBILITYMAP_VALID_BITS);
2538 }
2539 else if (all_frozen_set)
2540 {
2541 PageSetAllVisible(page);
2543 vmbuffer,
2544 VISIBILITYMAP_ALL_VISIBLE |
2545 VISIBILITYMAP_ALL_FROZEN,
2546 relation->rd_locator);
2547 }
2548
2549 /*
2550 * XXX Should we set PageSetPrunable on this page ? See heap_insert()
2551 */
2552
2553 MarkBufferDirty(buffer);
2554
2555 /* XLOG stuff */
2556 if (needwal)
2557 {
2558 XLogRecPtr recptr;
2559 xl_heap_multi_insert *xlrec;
2561 char *tupledata;
2562 int totaldatalen;
2565 int bufflags = 0;
2566
2567 /*
2568 * If the page was previously empty, we can reinit the page
2569 * instead of restoring the whole thing.
2570 */
2571 init = starting_with_empty_page;
2572
2573 /* allocate xl_heap_multi_insert struct from the scratch area */
2574 xlrec = (xl_heap_multi_insert *) scratchptr;
2575 scratchptr += SizeOfHeapMultiInsert;
2576
2577 /*
2578 * Allocate offsets array. Unless we're reinitializing the page,
2579 * in that case the tuples are stored in order starting at
2580 * FirstOffsetNumber and we don't need to store the offsets
2581 * explicitly.
2582 */
2585
2586 /* the rest of the scratch space is used for tuple data */
2587 tupledata = scratchptr;
2588
2589 /* check that the mutually exclusive flags are not both set */
2590 Assert(!(all_visible_cleared && all_frozen_set));
2591
2592 xlrec->flags = 0;
2593 if (all_visible_cleared)
2595
2596 /*
2597 * We don't have to worry about including a conflict xid in the
2598 * WAL record, as HEAP_INSERT_FROZEN intentionally violates
2599 * visibility rules.
2600 */
2601 if (all_frozen_set)
2603
2604 xlrec->ntuples = nthispage;
2605
2606 /*
2607 * Write out an xl_multi_insert_tuple and the tuple data itself
2608 * for each tuple.
2609 */
2611 {
2613 xl_multi_insert_tuple *tuphdr;
2614 int datalen;
2615
2618 /* xl_multi_insert_tuple needs two-byte alignment. */
2621
2625
2626 /* write bitmap [+ padding] [+ oid] + data */
2628 memcpy(scratchptr,
2630 datalen);
2631 tuphdr->datalen = datalen;
2632 scratchptr += datalen;
2633 }
2634 totaldatalen = scratchptr - tupledata;
2636
2637 if (need_tuple_data)
2639
2640 /*
2641 * Signal that this is the last xl_heap_multi_insert record
2642 * emitted by this call to heap_multi_insert(). Needed for logical
2643 * decoding so it knows when to cleanup temporary data.
2644 */
2645 if (ndone + nthispage == ntuples)
2647
2649 {
2650 info |= XLOG_HEAP_INIT_PAGE;
2651 bufflags |= REGBUF_WILL_INIT;
2652 }
2653
2654 /*
2655 * If we're doing logical decoding, include the new tuple data
2656 * even if we take a full-page image of the page.
2657 */
2658 if (need_tuple_data)
2659 bufflags |= REGBUF_KEEP_DATA;
2660
2661 XLogBeginInsert();
2664 if (all_frozen_set)
2665 XLogRegisterBuffer(1, vmbuffer, 0);
2666
2667 XLogRegisterBufData(0, tupledata, totaldatalen);
2668
2669 /* filtering by origin on a row level is much more efficient */
2671
2672 recptr = XLogInsert(RM_HEAP2_ID, info);
2673
2674 PageSetLSN(page, recptr);
2675 if (all_frozen_set)
2676 {
2679 }
2680 }
2681
2682 END_CRIT_SECTION();
2683
2684 if (all_frozen_set)
2686
2687 UnlockReleaseBuffer(buffer);
2688 ndone += nthispage;
2689
2690 /*
2691 * NB: Only release vmbuffer after inserting all tuples - it's fairly
2692 * likely that we'll insert into subsequent heap pages that are likely
2693 * to use the same vm page.
2694 */
2695 }
2696
2697 /* We're done with inserting all tuples, so release the last vmbuffer. */
2699 ReleaseBuffer(vmbuffer);
2700
2701 /*
2702 * We're done with the actual inserts. Check for conflicts again, to
2703 * ensure that all rw-conflicts in to these inserts are detected. Without
2704 * this final check, a sequential scan of the heap may have locked the
2705 * table after the "before" check, missing one opportunity to detect the
2706 * conflict, and then scanned the table before the new tuples were there,
2707 * missing the other chance to detect the conflict.
2708 *
2709 * For heap inserts, we only need to check for table-level SSI locks. Our
2710 * new tuples can't possibly conflict with existing tuple locks, and heap
2711 * page locks are only consolidated versions of tuple locks; they do not
2712 * lock "gaps" as index page locks do. So we don't need to specify a
2713 * buffer when making the call.
2714 */
2716
2717 /*
2718 * If tuples are cacheable, mark them for invalidation from the caches in
2719 * case we abort. Note it is OK to do this after releasing the buffer,
2720 * because the heaptuples data structure is all in local memory, not in
2721 * the shared buffer.
2722 */
2724 {
2727 }
2728
2729 /* copy t_self fields back to the caller's slots */
2732
2733 pgstat_count_heap_insert(relation, ntuples);
2734}
HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
Definition: execTuples.c:1833
static int heap_multi_insert_pages(HeapTuple *heaptuples, int done, int ntuples, Size saveFreeSpace)
Definition: heapam.c:2342
#define RelationGetTargetPageFreeSpace(relation, defaultff)
Definition: rel.h:390
Definition: heapam_xlog.h:182
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER]
Definition: heapam_xlog.h:185
Definition: heapam_xlog.h:191
uint8 visibilitymap_set_vmbits(BlockNumber heapBlk, Buffer vmBuf, uint8 flags, const RelFileLocator rlocator)
Definition: visibilitymap.c:347
References Assert(), AssertHasSnapshotForToast(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsDirty(), CacheInvalidateHeapTuple(), CHECK_FOR_INTERRUPTS, CheckForSerializableConflictIn(), PGAlignedBlock::data, xl_multi_insert_tuple::datalen, END_CRIT_SECTION, ExecFetchSlotHeapTuple(), xl_heap_multi_insert::flags, GetCurrentTransactionId(), HEAP_DEFAULT_FILLFACTOR, HEAP_INSERT_FROZEN, HEAP_INSERT_NO_LOGICAL, heap_multi_insert_pages(), heap_prepare_insert(), i, init, InvalidBlockNumber, InvalidBuffer, IsCatalogRelation(), ItemPointerGetOffsetNumber(), LockBuffer(), log_heap_new_cid(), MarkBufferDirty(), MAXALIGN, xl_heap_multi_insert::ntuples, xl_heap_multi_insert::offsets, PageClearAllVisible(), PageGetHeapFreeSpace(), PageGetMaxOffsetNumber(), PageIsAllVisible(), PageSetAllVisible(), PageSetLSN(), palloc(), pgstat_count_heap_insert(), RelationData::rd_locator, REGBUF_KEEP_DATA, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetBufferForTuple(), RelationGetRelid, RelationGetTargetPageFreeSpace, RelationIsAccessibleInLogicalDecoding, RelationIsLogicallyLogged, RelationNeedsWAL, RelationPutHeapTuple(), ReleaseBuffer(), SHORTALIGN, SizeOfHeapMultiInsert, SizeofHeapTupleHeader, SizeOfMultiInsertTuple, START_CRIT_SECTION, HeapTupleData::t_data, xl_multi_insert_tuple::t_hoff, HeapTupleHeaderData::t_hoff, xl_multi_insert_tuple::t_infomask, HeapTupleHeaderData::t_infomask, xl_multi_insert_tuple::t_infomask2, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleTableSlot::tts_tableOid, UnlockReleaseBuffer(), VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_clear(), visibilitymap_set_vmbits(), VISIBILITYMAP_VALID_BITS, XLH_INSERT_ALL_FROZEN_SET, XLH_INSERT_ALL_VISIBLE_CLEARED, XLH_INSERT_CONTAINS_NEW_TUPLE, XLH_INSERT_LAST_IN_MULTI, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP_INIT_PAGE, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), XLogRegisterData(), and XLogSetRecordFlags().
Referenced by CatalogTuplesMultiInsertWithInfo().
◆ heap_multi_insert_pages()
|
static |
Definition at line 2342 of file heapam.c.
2343{
2345 int npages = 1;
2346
2348 {
2350
2351 if (page_avail < tup_sz)
2352 {
2353 npages++;
2354 page_avail = BLCKSZ - SizeOfPageHeaderData - saveFreeSpace;
2355 }
2356 page_avail -= tup_sz;
2357 }
2358
2359 return npages;
2360}
struct ItemIdData ItemIdData
References i, MAXALIGN, and SizeOfPageHeaderData.
Referenced by heap_multi_insert().
◆ heap_pre_freeze_checks()
| void heap_pre_freeze_checks | ( | Buffer | buffer, |
| HeapTupleFreeze * | tuples, | ||
| int | ntuples | ||
| ) |
Definition at line 7353 of file heapam.c.
7355{
7357
7359 {
7362 HeapTupleHeader htup;
7363
7365
7366 /* Deliberately avoid relying on tuple hint bits here */
7368 {
7370
7376 xmin)));
7377 }
7378
7379 /*
7380 * TransactionIdDidAbort won't work reliably in the presence of XIDs
7381 * left behind by transactions that were in progress during a crash,
7382 * so we can only check that xmax didn't commit
7383 */
7385 {
7387
7393 xmax)));
7394 }
7395 }
7396}
static bool HeapTupleHeaderXminFrozen(const HeapTupleHeaderData *tup)
Definition: htup_details.h:350
static TransactionId HeapTupleHeaderGetRawXmin(const HeapTupleHeaderData *tup)
Definition: htup_details.h:318
References Assert(), BufferGetPage(), HeapTupleFreeze::checkflags, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, HEAP_FREEZE_CHECK_XMAX_ABORTED, HEAP_FREEZE_CHECK_XMIN_COMMITTED, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetRawXmin(), HeapTupleHeaderXminFrozen(), i, HeapTupleFreeze::offset, PageGetItem(), PageGetItemId(), TransactionIdDidCommit(), TransactionIdIsNormal, and unlikely.
Referenced by heap_page_will_freeze().
◆ heap_prepare_freeze_tuple()
| bool heap_prepare_freeze_tuple | ( | HeapTupleHeader | tuple, |
| const struct VacuumCutoffs * | cutoffs, | ||
| HeapPageFreeze * | pagefrz, | ||
| HeapTupleFreeze * | frz, | ||
| bool * | totally_frozen | ||
| ) |
Definition at line 7080 of file heapam.c.
7084{
7085 bool xmin_already_frozen = false,
7086 xmax_already_frozen = false;
7087 bool freeze_xmin = false,
7088 replace_xvac = false,
7089 replace_xmax = false,
7090 freeze_xmax = false;
7091 TransactionId xid;
7092
7096 frz->frzflags = 0;
7097 frz->checkflags = 0;
7098
7099 /*
7100 * Process xmin, while keeping track of whether it's already frozen, or
7101 * will become frozen iff our freeze plan is executed by caller (could be
7102 * neither).
7103 */
7104 xid = HeapTupleHeaderGetXmin(tuple);
7106 xmin_already_frozen = true;
7107 else
7108 {
7113 xid, cutoffs->relfrozenxid)));
7114
7115 /* Will set freeze_xmin flags in freeze plan below */
7117
7118 /* Verify that xmin committed if and when freeze plan is executed */
7119 if (freeze_xmin)
7121 }
7122
7123 /*
7124 * Old-style VACUUM FULL is gone, but we have to process xvac for as long
7125 * as we support having MOVED_OFF/MOVED_IN tuples in the database
7126 */
7127 xid = HeapTupleHeaderGetXvac(tuple);
7129 {
7132
7133 /*
7134 * For Xvac, we always freeze proactively. This allows totally_frozen
7135 * tracking to ignore xvac.
7136 */
7138
7139 /* Will set replace_xvac flags in freeze plan below */
7140 }
7141
7142 /* Now process xmax */
7143 xid = frz->xmax;
7145 {
7146 /* Raw xmax is a MultiXactId */
7147 TransactionId newxmax;
7148 uint16 flags;
7149
7150 /*
7151 * We will either remove xmax completely (in the "freeze_xmax" path),
7152 * process xmax by replacing it (in the "replace_xmax" path), or
7153 * perform no-op xmax processing. The only constraint is that the
7154 * FreezeLimit/MultiXactCutoff postcondition must never be violated.
7155 */
7157 &flags, pagefrz);
7158
7160 {
7161 /*
7162 * xmax is a MultiXactId, and nothing about it changes for now.
7163 * This is the only case where 'freeze_required' won't have been
7164 * set for us by FreezeMultiXactId, as well as the only case where
7165 * neither freeze_xmax nor replace_xmax are set (given a multi).
7166 *
7167 * This is a no-op, but the call to FreezeMultiXactId might have
7168 * ratcheted back NewRelfrozenXid and/or NewRelminMxid trackers
7169 * for us (the "freeze page" variants, specifically). That'll
7170 * make it safe for our caller to freeze the page later on, while
7171 * leaving this particular xmax undisturbed.
7172 *
7173 * FreezeMultiXactId is _not_ responsible for the "no freeze"
7174 * NewRelfrozenXid/NewRelminMxid trackers, though -- that's our
7175 * job. A call to heap_tuple_should_freeze for this same tuple
7176 * will take place below if 'freeze_required' isn't set already.
7177 * (This repeats work from FreezeMultiXactId, but allows "no
7178 * freeze" tracker maintenance to happen in only one place.)
7179 */
7182 }
7184 {
7185 /*
7186 * xmax will become an updater Xid (original MultiXact's updater
7187 * member Xid will be carried forward as a simple Xid in Xmax).
7188 */
7190
7191 /*
7192 * NB -- some of these transformations are only valid because we
7193 * know the return Xid is a tuple updater (i.e. not merely a
7194 * locker.) Also note that the only reason we don't explicitly
7195 * worry about HEAP_KEYS_UPDATED is because it lives in
7196 * t_infomask2 rather than t_infomask.
7197 */
7198 frz->t_infomask &= ~HEAP_XMAX_BITS;
7199 frz->xmax = newxmax;
7202 replace_xmax = true;
7203 }
7205 {
7206 uint16 newbits;
7207 uint16 newbits2;
7208
7209 /*
7210 * xmax is an old MultiXactId that we have to replace with a new
7211 * MultiXactId, to carry forward two or more original member XIDs.
7212 */
7214
7215 /*
7216 * We can't use GetMultiXactIdHintBits directly on the new multi
7217 * here; that routine initializes the masks to all zeroes, which
7218 * would lose other bits we need. Doing it this way ensures all
7219 * unrelated bits remain untouched.
7220 */
7221 frz->t_infomask &= ~HEAP_XMAX_BITS;
7222 frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
7223 GetMultiXactIdHintBits(newxmax, &newbits, &newbits2);
7224 frz->t_infomask |= newbits;
7225 frz->t_infomask2 |= newbits2;
7226 frz->xmax = newxmax;
7227 replace_xmax = true;
7228 }
7229 else
7230 {
7231 /*
7232 * Freeze plan for tuple "freezes xmax" in the strictest sense:
7233 * it'll leave nothing in xmax (neither an Xid nor a MultiXactId).
7234 */
7237
7238 /* Will set freeze_xmax flags in freeze plan below */
7239 freeze_xmax = true;
7240 }
7241
7242 /* MultiXactId processing forces freezing (barring FRM_NOOP case) */
7244 }
7246 {
7247 /* Raw xmax is normal XID */
7252 xid, cutoffs->relfrozenxid)));
7253
7254 /* Will set freeze_xmax flags in freeze plan below */
7256
7257 /*
7258 * Verify that xmax aborted if and when freeze plan is executed,
7259 * provided it's from an update. (A lock-only xmax can be removed
7260 * independent of this, since the lock is released at xact end.)
7261 */
7264 }
7266 {
7267 /* Raw xmax is InvalidTransactionId XID */
7269 xmax_already_frozen = true;
7270 }
7271 else
7275 xid, tuple->t_infomask)));
7276
7277 if (freeze_xmin)
7278 {
7279 Assert(!xmin_already_frozen);
7280
7282 }
7283 if (replace_xvac)
7284 {
7285 /*
7286 * If a MOVED_OFF tuple is not dead, the xvac transaction must have
7287 * failed; whereas a non-dead MOVED_IN tuple must mean the xvac
7288 * transaction succeeded.
7289 */
7293 else
7295 }
7296 if (replace_xmax)
7297 {
7298 Assert(!xmax_already_frozen && !freeze_xmax);
7300
7301 /* Already set replace_xmax flags in freeze plan earlier */
7302 }
7303 if (freeze_xmax)
7304 {
7305 Assert(!xmax_already_frozen && !replace_xmax);
7306
7308
7309 /*
7310 * The tuple might be marked either XMAX_INVALID or XMAX_COMMITTED +
7311 * LOCKED. Normalize to INVALID just to be sure no one gets confused.
7312 * Also get rid of the HEAP_KEYS_UPDATED bit.
7313 */
7314 frz->t_infomask &= ~HEAP_XMAX_BITS;
7316 frz->t_infomask2 &= ~HEAP_HOT_UPDATED;
7317 frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
7318 }
7319
7320 /*
7321 * Determine if this tuple is already totally frozen, or will become
7322 * totally frozen (provided caller executes freeze plans for the page)
7323 */
7324 *totally_frozen = ((freeze_xmin || xmin_already_frozen) &&
7325 (freeze_xmax || xmax_already_frozen));
7326
7328 xmax_already_frozen))
7329 {
7330 /*
7331 * So far no previous tuple from the page made freezing mandatory.
7332 * Does this tuple force caller to freeze the entire page?
7333 */
7334 pagefrz->freeze_required =
7335 heap_tuple_should_freeze(tuple, cutoffs,
7336 &pagefrz->NoFreezePageRelfrozenXid,
7337 &pagefrz->NoFreezePageRelminMxid);
7338 }
7339
7340 /* Tell caller if this tuple has a usable freeze plan set in *frz */
7341 return freeze_xmin || replace_xvac || replace_xmax || freeze_xmax;
7342}
static TransactionId FreezeMultiXactId(MultiXactId multi, uint16 t_infomask, const struct VacuumCutoffs *cutoffs, uint16 *flags, HeapPageFreeze *pagefrz)
Definition: heapam.c:6730
bool heap_tuple_should_freeze(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, TransactionId *NoFreezePageRelfrozenXid, MultiXactId *NoFreezePageRelminMxid)
Definition: heapam.c:7891
static TransactionId HeapTupleHeaderGetXvac(const HeapTupleHeaderData *tup)
Definition: htup_details.h:442
TransactionId NoFreezePageRelfrozenXid
Definition: heapam.h:219
static bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
Definition: transam.h:282
References Assert(), HeapTupleFreeze::checkflags, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, HeapPageFreeze::freeze_required, FreezeMultiXactId(), FRM_INVALIDATE_XMAX, FRM_MARK_COMMITTED, FRM_NOOP, FRM_RETURN_IS_MULTI, FRM_RETURN_IS_XID, HeapTupleFreeze::frzflags, GetMultiXactIdHintBits(), HEAP_FREEZE_CHECK_XMAX_ABORTED, HEAP_FREEZE_CHECK_XMIN_COMMITTED, HEAP_MOVED_OFF, heap_tuple_should_freeze(), HEAP_XMAX_COMMITTED, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMIN_FROZEN, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetXmin(), HeapTupleHeaderGetXvac(), InvalidTransactionId, VacuumCutoffs::MultiXactCutoff, MultiXactIdIsValid, MultiXactIdPrecedes(), HeapPageFreeze::NoFreezePageRelfrozenXid, HeapPageFreeze::NoFreezePageRelminMxid, VacuumCutoffs::OldestMxact, VacuumCutoffs::OldestXmin, VacuumCutoffs::relfrozenxid, HeapTupleFreeze::t_infomask, HeapTupleHeaderData::t_infomask, HeapTupleFreeze::t_infomask2, HeapTupleHeaderData::t_infomask2, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), TransactionIdPrecedesOrEquals(), XLH_FREEZE_XVAC, XLH_INVALID_XVAC, and HeapTupleFreeze::xmax.
Referenced by heap_freeze_tuple(), and heap_prune_record_unchanged_lp_normal().
◆ heap_prepare_insert()
|
static |
Definition at line 2294 of file heapam.c.
2296{
2297 /*
2298 * To allow parallel inserts, we need to ensure that they are safe to be
2299 * performed in workers. We have the infrastructure to allow parallel
2300 * inserts in general except for the cases where inserts generate a new
2301 * CommandId (eg. inserts into a table having a foreign key column).
2302 */
2305 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
2307
2314
2318
2319 /*
2320 * If the new tuple is too big for storage or contains already toasted
2321 * out-of-line attributes from some other relation, invoke the toaster.
2322 */
2324 relation->rd_rel->relkind != RELKIND_MATVIEW)
2325 {
2326 /* toast table entries should never be recursively toasted */
2328 return tup;
2329 }
2332 else
2333 return tup;
2334}
HeapTuple heap_toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup, int options)
Definition: heaptoast.c:96
static void HeapTupleHeaderSetXminFrozen(HeapTupleHeaderData *tup)
Definition: htup_details.h:370
static void HeapTupleHeaderSetCmin(HeapTupleHeaderData *tup, CommandId cid)
Definition: htup_details.h:422
References Assert(), ereport, errcode(), errmsg(), ERROR, HEAP2_XACT_MASK, HEAP_INSERT_FROZEN, heap_toast_insert_or_update(), HEAP_XACT_MASK, HEAP_XMAX_INVALID, HeapTupleHasExternal(), HeapTupleHeaderSetCmin(), HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), HeapTupleHeaderSetXminFrozen(), IsParallelWorker, RelationData::rd_rel, RelationGetRelid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_tableOid, and TOAST_TUPLE_THRESHOLD.
Referenced by heap_insert(), and heap_multi_insert().
◆ heap_prepare_pagescan()
| void heap_prepare_pagescan | ( | TableScanDesc | sscan | ) |
Definition at line 567 of file heapam.c.
568{
572 Snapshot snapshot;
573 Page page;
574 int lines;
575 bool all_visible;
576 bool check_serializable;
577
579
580 /* ensure we're not accidentally being used when not in pagemode */
583
584 /*
585 * Prune and repair fragmentation for the whole page, if possible.
586 */
588
589 /*
590 * We must hold share lock on the buffer content while examining tuple
591 * visibility. Afterwards, however, the tuples we have found to be
592 * visible are guaranteed good as long as we hold the buffer pin.
593 */
595
596 page = BufferGetPage(buffer);
597 lines = PageGetMaxOffsetNumber(page);
598
599 /*
600 * If the all-visible flag indicates that all tuples on the page are
601 * visible to everyone, we can skip the per-tuple visibility tests.
602 *
603 * Note: In hot standby, a tuple that's already visible to all
604 * transactions on the primary might still be invisible to a read-only
605 * transaction in the standby. We partly handle this problem by tracking
606 * the minimum xmin of visible tuples as the cut-off XID while marking a
607 * page all-visible on the primary and WAL log that along with the
608 * visibility map SET operation. In hot standby, we wait for (or abort)
609 * all transactions that can potentially may not see one or more tuples on
610 * the page. That's how index-only scans work fine in hot standby. A
611 * crucial difference between index-only scans and heap scans is that the
612 * index-only scan completely relies on the visibility map where as heap
613 * scan looks at the page-level PD_ALL_VISIBLE flag. We are not sure if
614 * the page-level flag can be trusted in the same way, because it might
615 * get propagated somehow without being explicitly WAL-logged, e.g. via a
616 * full page write. Until we can prove that beyond doubt, let's check each
617 * tuple for visibility the hard way.
618 */
620 check_serializable =
622
623 /*
624 * We call page_collect_tuples() with constant arguments, to get the
625 * compiler to constant fold the constant arguments. Separate calls with
626 * constant arguments, rather than variables, are needed on several
627 * compilers to actually perform constant folding.
628 */
630 {
633 block, lines, true, false);
634 else
636 block, lines, true, true);
637 }
638 else
639 {
642 block, lines, false, false);
643 else
645 block, lines, false, true);
646 }
647
649}
static pg_attribute_always_inline int page_collect_tuples(HeapScanDesc scan, Snapshot snapshot, Page page, Buffer buffer, BlockNumber block, int lines, bool all_visible, bool check_serializable)
Definition: heapam.c:517
bool CheckForSerializableConflictOutNeeded(Relation relation, Snapshot snapshot)
Definition: predicate.c:3991
void heap_page_prune_opt(Relation relation, Buffer buffer)
Definition: pruneheap.c:209
References Assert(), BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), CheckForSerializableConflictOutNeeded(), heap_page_prune_opt(), likely, LockBuffer(), page_collect_tuples(), PageGetMaxOffsetNumber(), PageIsAllVisible(), HeapScanDescData::rs_base, HeapScanDescData::rs_cblock, HeapScanDescData::rs_cbuf, TableScanDescData::rs_flags, HeapScanDescData::rs_ntuples, TableScanDescData::rs_rd, TableScanDescData::rs_snapshot, SO_ALLOW_PAGEMODE, and SnapshotData::takenDuringRecovery.
Referenced by heapam_scan_sample_next_block(), and heapgettup_pagemode().
◆ heap_rescan()
| void heap_rescan | ( | TableScanDesc | sscan, |
| ScanKey | key, | ||
| bool | set_params, | ||
| bool | allow_strat, | ||
| bool | allow_sync, | ||
| bool | allow_pagemode | ||
| ) |
Definition at line 1269 of file heapam.c.
1271{
1273
1274 if (set_params)
1275 {
1276 if (allow_strat)
1278 else
1280
1281 if (allow_sync)
1283 else
1285
1289 else
1291 }
1292
1293 /*
1294 * unpin scan buffers
1295 */
1297 {
1300 }
1301
1302 /*
1303 * SO_TYPE_BITMAPSCAN would be cleaned up here, but it does not hold any
1304 * additional data vs a normal HeapScan
1305 */
1306
1307 /*
1308 * The read stream is reset on rescan. This must be done before
1309 * initscan(), as some state referred to by read_stream_reset() is reset
1310 * in initscan().
1311 */
1314
1315 /*
1316 * reinitialize scan descriptor
1317 */
1319}
References BufferIsValid(), initscan(), InvalidBuffer, IsMVCCSnapshot, sort-test::key, read_stream_reset(), ReleaseBuffer(), HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, TableScanDescData::rs_flags, HeapScanDescData::rs_read_stream, TableScanDescData::rs_snapshot, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, and SO_ALLOW_SYNC.
◆ heap_scan_stream_read_next_parallel()
|
static |
Definition at line 247 of file heapam.c.
250{
252
255
257 {
258 /* parallel scan */
260 scan->rs_parallelworkerdata,
262 scan->rs_startblock,
263 scan->rs_numblocks);
264
265 /* may return InvalidBlockNumber if there are no more blocks */
267 scan->rs_parallelworkerdata,
270 }
271 else
272 {
276 }
277
279}
Definition: relscan.h:93
void table_block_parallelscan_startblock_init(Relation rel, ParallelBlockTableScanWorker pbscanwork, ParallelBlockTableScanDesc pbscan, BlockNumber startblock, BlockNumber numblocks)
Definition: tableam.c:459
BlockNumber table_block_parallelscan_nextpage(Relation rel, ParallelBlockTableScanWorker pbscanwork, ParallelBlockTableScanDesc pbscan)
Definition: tableam.c:554
References Assert(), HeapScanDescData::rs_base, HeapScanDescData::rs_dir, HeapScanDescData::rs_inited, HeapScanDescData::rs_numblocks, TableScanDescData::rs_parallel, HeapScanDescData::rs_parallelworkerdata, HeapScanDescData::rs_prefetch_block, TableScanDescData::rs_rd, HeapScanDescData::rs_startblock, ScanDirectionIsForward, table_block_parallelscan_nextpage(), table_block_parallelscan_startblock_init(), and unlikely.
Referenced by heap_beginscan().
◆ heap_scan_stream_read_next_serial()
|
static |
Definition at line 287 of file heapam.c.
290{
292
294 {
297 }
298 else
300 scan->rs_prefetch_block,
301 scan->rs_dir);
302
304}
static pg_noinline BlockNumber heapgettup_initial_block(HeapScanDesc scan, ScanDirection dir)
Definition: heapam.c:703
static BlockNumber heapgettup_advance_block(HeapScanDesc scan, BlockNumber block, ScanDirection dir)
Definition: heapam.c:827
References heapgettup_advance_block(), heapgettup_initial_block(), HeapScanDescData::rs_dir, HeapScanDescData::rs_inited, HeapScanDescData::rs_prefetch_block, and unlikely.
Referenced by heap_beginscan().
◆ heap_set_tidrange()
| void heap_set_tidrange | ( | TableScanDesc | sscan, |
| ItemPointer | mintid, | ||
| ItemPointer | maxtid | ||
| ) |
Definition at line 1440 of file heapam.c.
1442{
1444 BlockNumber startBlk;
1445 BlockNumber numBlks;
1446 ItemPointerData highestItem;
1447 ItemPointerData lowestItem;
1448
1449 /*
1450 * For relations without any pages, we can simply leave the TID range
1451 * unset. There will be no tuples to scan, therefore no tuples outside
1452 * the given TID range.
1453 */
1455 return;
1456
1457 /*
1458 * Set up some ItemPointers which point to the first and last possible
1459 * tuples in the heap.
1460 */
1463
1464 /*
1465 * If the given maximum TID is below the highest possible TID in the
1466 * relation, then restrict the range to that, otherwise we scan to the end
1467 * of the relation.
1468 */
1470 ItemPointerCopy(maxtid, &highestItem);
1471
1472 /*
1473 * If the given minimum TID is above the lowest possible TID in the
1474 * relation, then restrict the range to only scan for TIDs above that.
1475 */
1477 ItemPointerCopy(mintid, &lowestItem);
1478
1479 /*
1480 * Check for an empty range and protect from would be negative results
1481 * from the numBlks calculation below.
1482 */
1484 {
1485 /* Set an empty range of blocks to scan */
1486 heap_setscanlimits(sscan, 0, 0);
1487 return;
1488 }
1489
1490 /*
1491 * Calculate the first block and the number of blocks we must scan. We
1492 * could be more aggressive here and perform some more validation to try
1493 * and further narrow the scope of blocks to scan by checking if the
1494 * lowestItem has an offset above MaxOffsetNumber. In this case, we could
1495 * advance startBlk by one. Likewise, if highestItem has an offset of 0
1496 * we could scan one fewer blocks. However, such an optimization does not
1497 * seem worth troubling over, currently.
1498 */
1499 startBlk = ItemPointerGetBlockNumberNoCheck(&lowestItem);
1500
1501 numBlks = ItemPointerGetBlockNumberNoCheck(&highestItem) -
1502 ItemPointerGetBlockNumberNoCheck(&lowestItem) + 1;
1503
1504 /* Set the start block and number of blocks to scan */
1505 heap_setscanlimits(sscan, startBlk, numBlks);
1506
1507 /* Finally, set the TID range in sscan */
1510}
void heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks)
Definition: heapam.c:495
static BlockNumber ItemPointerGetBlockNumberNoCheck(const ItemPointerData *pointer)
Definition: itemptr.h:93
References FirstOffsetNumber, heap_setscanlimits(), ItemPointerCompare(), ItemPointerCopy(), ItemPointerGetBlockNumberNoCheck(), ItemPointerSet(), MaxOffsetNumber, TableScanDescData::rs_maxtid, TableScanDescData::rs_mintid, HeapScanDescData::rs_nblocks, TableScanDescData::st, and TableScanDescData::tidrange.
◆ heap_setscanlimits()
| void heap_setscanlimits | ( | TableScanDesc | sscan, |
| BlockNumber | startBlk, | ||
| BlockNumber | numBlks | ||
| ) |
Definition at line 495 of file heapam.c.
496{
498
500 /* else rs_startblock is significant */
502
503 /* Check startBlk is valid (but allow case of zero blocks...) */
504 Assert(startBlk == 0 || startBlk < scan->rs_nblocks);
505
506 scan->rs_startblock = startBlk;
507 scan->rs_numblocks = numBlks;
508}
References Assert(), HeapScanDescData::rs_base, TableScanDescData::rs_flags, HeapScanDescData::rs_inited, HeapScanDescData::rs_numblocks, HeapScanDescData::rs_startblock, and SO_ALLOW_SYNC.
Referenced by heap_set_tidrange(), and heapam_index_build_range_scan().
◆ heap_tuple_needs_eventual_freeze()
| bool heap_tuple_needs_eventual_freeze | ( | HeapTupleHeader | tuple | ) |
Definition at line 7836 of file heapam.c.
7837{
7838 TransactionId xid;
7839
7840 /*
7841 * If xmin is a normal transaction ID, this tuple is definitely not
7842 * frozen.
7843 */
7844 xid = HeapTupleHeaderGetXmin(tuple);
7846 return true;
7847
7848 /*
7849 * If xmax is a valid xact or multixact, this tuple is also not frozen.
7850 */
7852 {
7853 MultiXactId multi;
7854
7855 multi = HeapTupleHeaderGetRawXmax(tuple);
7857 return true;
7858 }
7859 else
7860 {
7861 xid = HeapTupleHeaderGetRawXmax(tuple);
7863 return true;
7864 }
7865
7867 {
7868 xid = HeapTupleHeaderGetXvac(tuple);
7870 return true;
7871 }
7872
7873 return false;
7874}
References HEAP_MOVED, HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetXmin(), HeapTupleHeaderGetXvac(), MultiXactIdIsValid, HeapTupleHeaderData::t_infomask, and TransactionIdIsNormal.
Referenced by collect_corrupt_items(), and heap_page_would_be_all_visible().
◆ heap_tuple_should_freeze()
| bool heap_tuple_should_freeze | ( | HeapTupleHeader | tuple, |
| const struct VacuumCutoffs * | cutoffs, | ||
| TransactionId * | NoFreezePageRelfrozenXid, | ||
| MultiXactId * | NoFreezePageRelminMxid | ||
| ) |
Definition at line 7891 of file heapam.c.
7895{
7896 TransactionId xid;
7897 MultiXactId multi;
7898 bool freeze = false;
7899
7900 /* First deal with xmin */
7901 xid = HeapTupleHeaderGetXmin(tuple);
7903 {
7906 *NoFreezePageRelfrozenXid = xid;
7908 freeze = true;
7909 }
7910
7911 /* Now deal with xmax */
7912 xid = InvalidTransactionId;
7913 multi = InvalidMultiXactId;
7915 multi = HeapTupleHeaderGetRawXmax(tuple);
7916 else
7917 xid = HeapTupleHeaderGetRawXmax(tuple);
7918
7920 {
7922 /* xmax is a non-permanent XID */
7924 *NoFreezePageRelfrozenXid = xid;
7926 freeze = true;
7927 }
7929 {
7930 /* xmax is a permanent XID or invalid MultiXactId/XID */
7931 }
7933 {
7934 /* xmax is a pg_upgrade'd MultiXact, which can't have updater XID */
7936 *NoFreezePageRelminMxid = multi;
7937 /* heap_prepare_freeze_tuple always freezes pg_upgrade'd xmax */
7938 freeze = true;
7939 }
7940 else
7941 {
7942 /* xmax is a MultiXactId that may have an updater XID */
7943 MultiXactMember *members;
7944 int nmembers;
7945
7948 *NoFreezePageRelminMxid = multi;
7950 freeze = true;
7951
7952 /* need to check whether any member of the mxact is old */
7955
7957 {
7961 *NoFreezePageRelfrozenXid = xid;
7963 freeze = true;
7964 }
7965 if (nmembers > 0)
7966 pfree(members);
7967 }
7968
7970 {
7971 xid = HeapTupleHeaderGetXvac(tuple);
7973 {
7976 *NoFreezePageRelfrozenXid = xid;
7977 /* heap_prepare_freeze_tuple forces xvac freezing */
7978 freeze = true;
7979 }
7980 }
7981
7982 return freeze;
7983}
bool MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:3283
References Assert(), VacuumCutoffs::FreezeLimit, GetMultiXactIdMembers(), HEAP_LOCKED_UPGRADED(), HEAP_MOVED, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetXmin(), HeapTupleHeaderGetXvac(), i, InvalidMultiXactId, InvalidTransactionId, VacuumCutoffs::MultiXactCutoff, MultiXactIdIsValid, MultiXactIdPrecedes(), MultiXactIdPrecedesOrEquals(), pfree(), VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, HeapTupleHeaderData::t_infomask, TransactionIdIsNormal, TransactionIdPrecedes(), TransactionIdPrecedesOrEquals(), and MultiXactMember::xid.
Referenced by heap_prepare_freeze_tuple(), and lazy_scan_noprune().
◆ heap_update()
| TM_Result heap_update | ( | Relation | relation, |
| const ItemPointerData * | otid, | ||
| HeapTuple | newtup, | ||
| CommandId | cid, | ||
| Snapshot | crosscheck, | ||
| bool | wait, | ||
| TM_FailureData * | tmfd, | ||
| LockTupleMode * | lockmode, | ||
| TU_UpdateIndexes * | update_indexes | ||
| ) |
Definition at line 3273 of file heapam.c.
3277{
3278 TM_Result result;
3280 Bitmapset *hot_attrs;
3281 Bitmapset *sum_attrs;
3282 Bitmapset *key_attrs;
3283 Bitmapset *id_attrs;
3284 Bitmapset *interesting_attrs;
3285 Bitmapset *modified_attrs;
3286 ItemId lp;
3287 HeapTupleData oldtup;
3288 HeapTuple heaptup;
3289 HeapTuple old_key_tuple = NULL;
3290 bool old_key_copied = false;
3291 Page page;
3292 BlockNumber block;
3293 MultiXactStatus mxact_status;
3294 Buffer buffer,
3295 newbuf,
3296 vmbuffer = InvalidBuffer,
3297 vmbuffer_new = InvalidBuffer;
3298 bool need_toast;
3299 Size newtupsize,
3300 pagefree;
3301 bool have_tuple_lock = false;
3302 bool iscombo;
3303 bool use_hot_update = false;
3304 bool summarized_update = false;
3305 bool key_intact;
3306 bool all_visible_cleared = false;
3307 bool all_visible_cleared_new = false;
3308 bool checked_lockers;
3309 bool locker_remains;
3310 bool id_has_external = false;
3311 TransactionId xmax_new_tuple,
3312 xmax_old_tuple;
3313 uint16 infomask_old_tuple,
3314 infomask2_old_tuple,
3315 infomask_new_tuple,
3316 infomask2_new_tuple;
3317
3319
3320 /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
3322 RelationGetNumberOfAttributes(relation));
3323
3324 AssertHasSnapshotForToast(relation);
3325
3326 /*
3327 * Forbid this during a parallel operation, lest it allocate a combo CID.
3328 * Other workers might need that combo CID for visibility checks, and we
3329 * have no provision for broadcasting it to them.
3330 */
3333 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3335
3336#ifdef USE_ASSERT_CHECKING
3337 check_lock_if_inplace_updateable_rel(relation, otid, newtup);
3338#endif
3339
3340 /*
3341 * Fetch the list of attributes to be checked for various operations.
3342 *
3343 * For HOT considerations, this is wasted effort if we fail to update or
3344 * have to put the new tuple on a different page. But we must compute the
3345 * list before obtaining buffer lock --- in the worst case, if we are
3346 * doing an update on one of the relevant system catalogs, we could
3347 * deadlock if we try to fetch the list later. In any case, the relcache
3348 * caches the data so this is usually pretty cheap.
3349 *
3350 * We also need columns used by the replica identity and columns that are
3351 * considered the "key" of rows in the table.
3352 *
3353 * Note that we get copies of each bitmap, so we need not worry about
3354 * relcache flush happening midway through.
3355 */
3356 hot_attrs = RelationGetIndexAttrBitmap(relation,
3358 sum_attrs = RelationGetIndexAttrBitmap(relation,
3359 INDEX_ATTR_BITMAP_SUMMARIZED);
3361 id_attrs = RelationGetIndexAttrBitmap(relation,
3363 interesting_attrs = NULL;
3364 interesting_attrs = bms_add_members(interesting_attrs, hot_attrs);
3365 interesting_attrs = bms_add_members(interesting_attrs, sum_attrs);
3366 interesting_attrs = bms_add_members(interesting_attrs, key_attrs);
3367 interesting_attrs = bms_add_members(interesting_attrs, id_attrs);
3368
3369 block = ItemPointerGetBlockNumber(otid);
3371 buffer = ReadBuffer(relation, block);
3372 page = BufferGetPage(buffer);
3373
3374 /*
3375 * Before locking the buffer, pin the visibility map page if it appears to
3376 * be necessary. Since we haven't got the lock yet, someone else might be
3377 * in the middle of changing this, so we'll need to recheck after we have
3378 * the lock.
3379 */
3381 visibilitymap_pin(relation, block, &vmbuffer);
3382
3384
3386
3387 /*
3388 * Usually, a buffer pin and/or snapshot blocks pruning of otid, ensuring
3389 * we see LP_NORMAL here. When the otid origin is a syscache, we may have
3390 * neither a pin nor a snapshot. Hence, we may see other LP_ states, each
3391 * of which indicates concurrent pruning.
3392 *
3393 * Failing with TM_Updated would be most accurate. However, unlike other
3394 * TM_Updated scenarios, we don't know the successor ctid in LP_UNUSED and
3395 * LP_DEAD cases. While the distinction between TM_Updated and TM_Deleted
3396 * does matter to SQL statements UPDATE and MERGE, those SQL statements
3397 * hold a snapshot that ensures LP_NORMAL. Hence, the choice between
3398 * TM_Updated and TM_Deleted affects only the wording of error messages.
3399 * Settle on TM_Deleted, for two reasons. First, it avoids complicating
3400 * the specification of when tmfd->ctid is valid. Second, it creates
3401 * error log evidence that we took this branch.
3402 *
3403 * Since it's possible to see LP_UNUSED at otid, it's also possible to see
3404 * LP_NORMAL for a tuple that replaced LP_UNUSED. If it's a tuple for an
3405 * unrelated row, we'll fail with "duplicate key value violates unique".
3406 * XXX if otid is the live, newer version of the newtup row, we'll discard
3407 * changes originating in versions of this catalog row after the version
3408 * the caller got from syscache. See syscache-update-pruned.spec.
3409 */
3411 {
3413
3414 UnlockReleaseBuffer(buffer);
3415 Assert(!have_tuple_lock);
3417 ReleaseBuffer(vmbuffer);
3418 tmfd->ctid = *otid;
3421 *update_indexes = TU_None;
3422
3423 bms_free(hot_attrs);
3424 bms_free(sum_attrs);
3425 bms_free(key_attrs);
3426 bms_free(id_attrs);
3427 /* modified_attrs not yet initialized */
3428 bms_free(interesting_attrs);
3430 }
3431
3432 /*
3433 * Fill in enough data in oldtup for HeapDetermineColumnsInfo to work
3434 * properly.
3435 */
3439 oldtup.t_self = *otid;
3440
3441 /* the new tuple is ready, except for this: */
3443
3444 /*
3445 * Determine columns modified by the update. Additionally, identify
3446 * whether any of the unmodified replica identity key attributes in the
3447 * old tuple is externally stored or not. This is required because for
3448 * such attributes the flattened value won't be WAL logged as part of the
3449 * new tuple so we must include it as part of the old_key_tuple. See
3450 * ExtractReplicaIdentity.
3451 */
3452 modified_attrs = HeapDetermineColumnsInfo(relation, interesting_attrs,
3453 id_attrs, &oldtup,
3454 newtup, &id_has_external);
3455
3456 /*
3457 * If we're not updating any "key" column, we can grab a weaker lock type.
3458 * This allows for more concurrency when we are running simultaneously
3459 * with foreign key checks.
3460 *
3461 * Note that if a column gets detoasted while executing the update, but
3462 * the value ends up being the same, this test will fail and we will use
3463 * the stronger lock. This is acceptable; the important case to optimize
3464 * is updates that don't manipulate key columns, not those that
3465 * serendipitously arrive at the same key values.
3466 */
3468 {
3469 *lockmode = LockTupleNoKeyExclusive;
3470 mxact_status = MultiXactStatusNoKeyUpdate;
3471 key_intact = true;
3472
3473 /*
3474 * If this is the first possibly-multixact-able operation in the
3475 * current transaction, set my per-backend OldestMemberMXactId
3476 * setting. We can be certain that the transaction will never become a
3477 * member of any older MultiXactIds than that. (We have to do this
3478 * even if we end up just using our own TransactionId below, since
3479 * some other backend could incorporate our XID into a MultiXact
3480 * immediately afterwards.)
3481 */
3482 MultiXactIdSetOldestMember();
3483 }
3484 else
3485 {
3486 *lockmode = LockTupleExclusive;
3487 mxact_status = MultiXactStatusUpdate;
3488 key_intact = false;
3489 }
3490
3491 /*
3492 * Note: beyond this point, use oldtup not otid to refer to old tuple.
3493 * otid may very well point at newtup->t_self, which we will overwrite
3494 * with the new tuple's location, so there's great risk of confusion if we
3495 * use otid anymore.
3496 */
3497
3498l2:
3499 checked_lockers = false;
3500 locker_remains = false;
3501 result = HeapTupleSatisfiesUpdate(&oldtup, cid, buffer);
3502
3503 /* see below about the "no wait" case */
3505
3507 {
3508 UnlockReleaseBuffer(buffer);
3510 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
3512 }
3514 {
3515 TransactionId xwait;
3516 uint16 infomask;
3517 bool can_continue = false;
3518
3519 /*
3520 * XXX note that we don't consider the "no wait" case here. This
3521 * isn't a problem currently because no caller uses that case, but it
3522 * should be fixed if such a caller is introduced. It wasn't a
3523 * problem previously because this code would always wait, but now
3524 * that some tuple locks do not conflict with one of the lock modes we
3525 * use, it is possible that this case is interesting to handle
3526 * specially.
3527 *
3528 * This may cause failures with third-party code that calls
3529 * heap_update directly.
3530 */
3531
3532 /* must copy state data before unlocking buffer */
3535
3536 /*
3537 * Now we have to do something about the existing locker. If it's a
3538 * multi, sleep on it; we might be awakened before it is completely
3539 * gone (or even not sleep at all in some cases); we need to preserve
3540 * it as locker, unless it is gone completely.
3541 *
3542 * If it's not a multi, we need to check for sleeping conditions
3543 * before actually going to sleep. If the update doesn't conflict
3544 * with the locks, we just continue without sleeping (but making sure
3545 * it is preserved).
3546 *
3547 * Before sleeping, we need to acquire tuple lock to establish our
3548 * priority for the tuple (see heap_lock_tuple). LockTuple will
3549 * release us when we are next-in-line for the tuple. Note we must
3550 * not acquire the tuple lock until we're sure we're going to sleep;
3551 * otherwise we're open for race conditions with other transactions
3552 * holding the tuple lock which sleep on us.
3553 *
3554 * If we are forced to "start over" below, we keep the tuple lock;
3555 * this arranges that we stay at the head of the line while rechecking
3556 * tuple state.
3557 */
3559 {
3560 TransactionId update_xact;
3561 int remain;
3562 bool current_is_member = false;
3563
3565 *lockmode, ¤t_is_member))
3566 {
3568
3569 /*
3570 * Acquire the lock, if necessary (but skip it when we're
3571 * requesting a lock and already have one; avoids deadlock).
3572 */
3573 if (!current_is_member)
3575 LockWaitBlock, &have_tuple_lock);
3576
3577 /* wait for multixact */
3580 &remain);
3581 checked_lockers = true;
3582 locker_remains = remain != 0;
3584
3585 /*
3586 * If xwait had just locked the tuple then some other xact
3587 * could update this tuple before we get to this point. Check
3588 * for xmax change, and start over if so.
3589 */
3591 infomask) ||
3593 xwait))
3594 goto l2;
3595 }
3596
3597 /*
3598 * Note that the multixact may not be done by now. It could have
3599 * surviving members; our own xact or other subxacts of this
3600 * backend, and also any other concurrent transaction that locked
3601 * the tuple with LockTupleKeyShare if we only got
3602 * LockTupleNoKeyExclusive. If this is the case, we have to be
3603 * careful to mark the updated tuple with the surviving members in
3604 * Xmax.
3605 *
3606 * Note that there could have been another update in the
3607 * MultiXact. In that case, we need to check whether it committed
3608 * or aborted. If it aborted we are safe to update it again;
3609 * otherwise there is an update conflict, and we have to return
3610 * TableTuple{Deleted, Updated} below.
3611 *
3612 * In the LockTupleExclusive case, we still need to preserve the
3613 * surviving members: those would include the tuple locks we had
3614 * before this one, which are important to keep in case this
3615 * subxact aborts.
3616 */
3619 else
3620 update_xact = InvalidTransactionId;
3621
3622 /*
3623 * There was no UPDATE in the MultiXact; or it aborted. No
3624 * TransactionIdIsInProgress() call needed here, since we called
3625 * MultiXactIdWait() above.
3626 */
3628 TransactionIdDidAbort(update_xact))
3629 can_continue = true;
3630 }
3632 {
3633 /*
3634 * The only locker is ourselves; we can avoid grabbing the tuple
3635 * lock here, but must preserve our locking information.
3636 */
3637 checked_lockers = true;
3638 locker_remains = true;
3639 can_continue = true;
3640 }
3642 {
3643 /*
3644 * If it's just a key-share locker, and we're not changing the key
3645 * columns, we don't need to wait for it to end; but we need to
3646 * preserve it as locker.
3647 */
3648 checked_lockers = true;
3649 locker_remains = true;
3650 can_continue = true;
3651 }
3652 else
3653 {
3654 /*
3655 * Wait for regular transaction to end; but first, acquire tuple
3656 * lock.
3657 */
3660 LockWaitBlock, &have_tuple_lock);
3662 XLTW_Update);
3663 checked_lockers = true;
3665
3666 /*
3667 * xwait is done, but if xwait had just locked the tuple then some
3668 * other xact could update this tuple before we get to this point.
3669 * Check for xmax change, and start over if so.
3670 */
3672 !TransactionIdEquals(xwait,
3674 goto l2;
3675
3676 /* Otherwise check if it committed or aborted */
3679 can_continue = true;
3680 }
3681
3682 if (can_continue)
3683 result = TM_Ok;
3685 result = TM_Updated;
3686 else
3687 result = TM_Deleted;
3688 }
3689
3690 /* Sanity check the result HeapTupleSatisfiesUpdate() and the logic above */
3692 {
3694 result == TM_Updated ||
3695 result == TM_Deleted ||
3696 result == TM_BeingModified);
3700 }
3701
3703 {
3704 /* Perform additional check for transaction-snapshot mode RI updates */
3706 result = TM_Updated;
3707 }
3708
3710 {
3715 else
3717 UnlockReleaseBuffer(buffer);
3718 if (have_tuple_lock)
3721 ReleaseBuffer(vmbuffer);
3722 *update_indexes = TU_None;
3723
3724 bms_free(hot_attrs);
3725 bms_free(sum_attrs);
3726 bms_free(key_attrs);
3727 bms_free(id_attrs);
3728 bms_free(modified_attrs);
3729 bms_free(interesting_attrs);
3730 return result;
3731 }
3732
3733 /*
3734 * If we didn't pin the visibility map page and the page has become all
3735 * visible while we were busy locking the buffer, or during some
3736 * subsequent window during which we had it unlocked, we'll have to unlock
3737 * and re-lock, to avoid holding the buffer lock across an I/O. That's a
3738 * bit unfortunate, especially since we'll now have to recheck whether the
3739 * tuple has been locked or updated under us, but hopefully it won't
3740 * happen very often.
3741 */
3743 {
3745 visibilitymap_pin(relation, block, &vmbuffer);
3747 goto l2;
3748 }
3749
3750 /* Fill in transaction status data */
3751
3752 /*
3753 * If the tuple we're updating is locked, we need to preserve the locking
3754 * info in the old tuple's Xmax. Prepare a new Xmax value for this.
3755 */
3759 xid, *lockmode, true,
3760 &xmax_old_tuple, &infomask_old_tuple,
3761 &infomask2_old_tuple);
3762
3763 /*
3764 * And also prepare an Xmax value for the new copy of the tuple. If there
3765 * was no xmax previously, or there was one but all lockers are now gone,
3766 * then use InvalidTransactionId; otherwise, get the xmax from the old
3767 * tuple. (In rare cases that might also be InvalidTransactionId and yet
3768 * not have the HEAP_XMAX_INVALID bit set; that's fine.)
3769 */
3772 (checked_lockers && !locker_remains))
3773 xmax_new_tuple = InvalidTransactionId;
3774 else
3776
3778 {
3779 infomask_new_tuple = HEAP_XMAX_INVALID;
3780 infomask2_new_tuple = 0;
3781 }
3782 else
3783 {
3784 /*
3785 * If we found a valid Xmax for the new tuple, then the infomask bits
3786 * to use on the new tuple depend on what was there on the old one.
3787 * Note that since we're doing an update, the only possibility is that
3788 * the lockers had FOR KEY SHARE lock.
3789 */
3791 {
3792 GetMultiXactIdHintBits(xmax_new_tuple, &infomask_new_tuple,
3793 &infomask2_new_tuple);
3794 }
3795 else
3796 {
3798 infomask2_new_tuple = 0;
3799 }
3800 }
3801
3802 /*
3803 * Prepare the new tuple with the appropriate initial values of Xmin and
3804 * Xmax, as well as initial infomask bits as computed above.
3805 */
3813
3814 /*
3815 * Replace cid with a combo CID if necessary. Note that we already put
3816 * the plain cid into the new tuple.
3817 */
3819
3820 /*
3821 * If the toaster needs to be activated, OR if the new tuple will not fit
3822 * on the same page as the old, then we need to release the content lock
3823 * (but not the pin!) on the old tuple's buffer while we are off doing
3824 * TOAST and/or table-file-extension work. We must mark the old tuple to
3825 * show that it's locked, else other processes may try to update it
3826 * themselves.
3827 *
3828 * We need to invoke the toaster if there are already any out-of-line
3829 * toasted values present, or if the new tuple is over-threshold.
3830 */
3832 relation->rd_rel->relkind != RELKIND_MATVIEW)
3833 {
3834 /* toast table entries should never be recursively toasted */
3837 need_toast = false;
3838 }
3839 else
3840 need_toast = (HeapTupleHasExternal(&oldtup) ||
3841 HeapTupleHasExternal(newtup) ||
3843
3844 pagefree = PageGetHeapFreeSpace(page);
3845
3847
3848 if (need_toast || newtupsize > pagefree)
3849 {
3850 TransactionId xmax_lock_old_tuple;
3851 uint16 infomask_lock_old_tuple,
3852 infomask2_lock_old_tuple;
3853 bool cleared_all_frozen = false;
3854
3855 /*
3856 * To prevent concurrent sessions from updating the tuple, we have to
3857 * temporarily mark it locked, while we release the page-level lock.
3858 *
3859 * To satisfy the rule that any xid potentially appearing in a buffer
3860 * written out to disk, we unfortunately have to WAL log this
3861 * temporary modification. We can reuse xl_heap_lock for this
3862 * purpose. If we crash/error before following through with the
3863 * actual update, xmax will be of an aborted transaction, allowing
3864 * other sessions to proceed.
3865 */
3866
3867 /*
3868 * Compute xmax / infomask appropriate for locking the tuple. This has
3869 * to be done separately from the combo that's going to be used for
3870 * updating, because the potentially created multixact would otherwise
3871 * be wrong.
3872 */
3876 xid, *lockmode, false,
3877 &xmax_lock_old_tuple, &infomask_lock_old_tuple,
3878 &infomask2_lock_old_tuple);
3879
3881
3882 START_CRIT_SECTION();
3883
3884 /* Clear obsolete visibility flags ... */
3887 HeapTupleClearHotUpdated(&oldtup);
3888 /* ... and store info about transaction updating this tuple */
3894
3895 /* temporarily make it look not-updated, but locked */
3897
3898 /*
3899 * Clear all-frozen bit on visibility map if needed. We could
3900 * immediately reset ALL_VISIBLE, but given that the WAL logging
3901 * overhead would be unchanged, that doesn't seem necessarily
3902 * worthwhile.
3903 */
3905 visibilitymap_clear(relation, block, vmbuffer,
3906 VISIBILITYMAP_ALL_FROZEN))
3907 cleared_all_frozen = true;
3908
3909 MarkBufferDirty(buffer);
3910
3912 {
3913 xl_heap_lock xlrec;
3914 XLogRecPtr recptr;
3915
3916 XLogBeginInsert();
3918
3920 xlrec.xmax = xmax_lock_old_tuple;
3923 xlrec.flags =
3924 cleared_all_frozen ? XLH_LOCK_ALL_FROZEN_CLEARED : 0;
3927 PageSetLSN(page, recptr);
3928 }
3929
3930 END_CRIT_SECTION();
3931
3933
3934 /*
3935 * Let the toaster do its thing, if needed.
3936 *
3937 * Note: below this point, heaptup is the data we actually intend to
3938 * store into the relation; newtup is the caller's original untoasted
3939 * data.
3940 */
3941 if (need_toast)
3942 {
3943 /* Note we always use WAL and FSM during updates */
3944 heaptup = heap_toast_insert_or_update(relation, newtup, &oldtup, 0);
3946 }
3947 else
3948 heaptup = newtup;
3949
3950 /*
3951 * Now, do we need a new page for the tuple, or not? This is a bit
3952 * tricky since someone else could have added tuples to the page while
3953 * we weren't looking. We have to recheck the available space after
3954 * reacquiring the buffer lock. But don't bother to do that if the
3955 * former amount of free space is still not enough; it's unlikely
3956 * there's more free now than before.
3957 *
3958 * What's more, if we need to get a new page, we will need to acquire
3959 * buffer locks on both old and new pages. To avoid deadlock against
3960 * some other backend trying to get the same two locks in the other
3961 * order, we must be consistent about the order we get the locks in.
3962 * We use the rule "lock the lower-numbered page of the relation
3963 * first". To implement this, we must do RelationGetBufferForTuple
3964 * while not holding the lock on the old page, and we must rely on it
3965 * to get the locks on both pages in the correct order.
3966 *
3967 * Another consideration is that we need visibility map page pin(s) if
3968 * we will have to clear the all-visible flag on either page. If we
3969 * call RelationGetBufferForTuple, we rely on it to acquire any such
3970 * pins; but if we don't, we have to handle that here. Hence we need
3971 * a loop.
3972 */
3973 for (;;)
3974 {
3975 if (newtupsize > pagefree)
3976 {
3977 /* It doesn't fit, must use RelationGetBufferForTuple. */
3979 buffer, 0, NULL,
3980 &vmbuffer_new, &vmbuffer,
3981 0);
3982 /* We're all done. */
3983 break;
3984 }
3985 /* Acquire VM page pin if needed and we don't have it. */
3987 visibilitymap_pin(relation, block, &vmbuffer);
3988 /* Re-acquire the lock on the old tuple's page. */
3990 /* Re-check using the up-to-date free space */
3991 pagefree = PageGetHeapFreeSpace(page);
3992 if (newtupsize > pagefree ||
3994 {
3995 /*
3996 * Rats, it doesn't fit anymore, or somebody just now set the
3997 * all-visible flag. We must now unlock and loop to avoid
3998 * deadlock. Fortunately, this path should seldom be taken.
3999 */
4001 }
4002 else
4003 {
4004 /* We're all done. */
4005 newbuf = buffer;
4006 break;
4007 }
4008 }
4009 }
4010 else
4011 {
4012 /* No TOAST work needed, and it'll fit on same page */
4013 newbuf = buffer;
4014 heaptup = newtup;
4015 }
4016
4017 /*
4018 * We're about to do the actual update -- check for conflict first, to
4019 * avoid possibly having to roll back work we've just done.
4020 *
4021 * This is safe without a recheck as long as there is no possibility of
4022 * another process scanning the pages between this check and the update
4023 * being visible to the scan (i.e., exclusive buffer content lock(s) are
4024 * continuously held from this point until the tuple update is visible).
4025 *
4026 * For the new tuple the only check needed is at the relation level, but
4027 * since both tuples are in the same relation and the check for oldtup
4028 * will include checking the relation level, there is no benefit to a
4029 * separate check for the new tuple.
4030 */
4032 BufferGetBlockNumber(buffer));
4033
4034 /*
4035 * At this point newbuf and buffer are both pinned and locked, and newbuf
4036 * has enough space for the new tuple. If they are the same buffer, only
4037 * one pin is held.
4038 */
4039
4040 if (newbuf == buffer)
4041 {
4042 /*
4043 * Since the new tuple is going into the same page, we might be able
4044 * to do a HOT update. Check if any of the index columns have been
4045 * changed.
4046 */
4048 {
4049 use_hot_update = true;
4050
4051 /*
4052 * If none of the columns that are used in hot-blocking indexes
4053 * were updated, we can apply HOT, but we do still need to check
4054 * if we need to update the summarizing indexes, and update those
4055 * indexes if the columns were updated, or we may fail to detect
4056 * e.g. value bound changes in BRIN minmax indexes.
4057 */
4059 summarized_update = true;
4060 }
4061 }
4062 else
4063 {
4064 /* Set a hint that the old page could use prune/defrag */
4065 PageSetFull(page);
4066 }
4067
4068 /*
4069 * Compute replica identity tuple before entering the critical section so
4070 * we don't PANIC upon a memory allocation failure.
4071 * ExtractReplicaIdentity() will return NULL if nothing needs to be
4072 * logged. Pass old key required as true only if the replica identity key
4073 * columns are modified or it has external data.
4074 */
4075 old_key_tuple = ExtractReplicaIdentity(relation, &oldtup,
4076 bms_overlap(modified_attrs, id_attrs) ||
4077 id_has_external,
4078 &old_key_copied);
4079
4080 /* NO EREPORT(ERROR) from here till changes are logged */
4081 START_CRIT_SECTION();
4082
4083 /*
4084 * If this transaction commits, the old tuple will become DEAD sooner or
4085 * later. Set flag that this page is a candidate for pruning once our xid
4086 * falls below the OldestXmin horizon. If the transaction finally aborts,
4087 * the subsequent page pruning will be a no-op and the hint will be
4088 * cleared.
4089 *
4090 * XXX Should we set hint on newbuf as well? If the transaction aborts,
4091 * there would be a prunable tuple in the newbuf; but for now we choose
4092 * not to optimize for aborts. Note that heap_xlog_update must be kept in
4093 * sync if this decision changes.
4094 */
4095 PageSetPrunable(page, xid);
4096
4097 if (use_hot_update)
4098 {
4099 /* Mark the old tuple as HOT-updated */
4100 HeapTupleSetHotUpdated(&oldtup);
4101 /* And mark the new tuple as heap-only */
4102 HeapTupleSetHeapOnly(heaptup);
4103 /* Mark the caller's copy too, in case different from heaptup */
4104 HeapTupleSetHeapOnly(newtup);
4105 }
4106 else
4107 {
4108 /* Make sure tuples are correctly marked as not-HOT */
4109 HeapTupleClearHotUpdated(&oldtup);
4110 HeapTupleClearHeapOnly(heaptup);
4111 HeapTupleClearHeapOnly(newtup);
4112 }
4113
4115
4116
4117 /* Clear obsolete visibility flags, possibly set by ourselves above... */
4120 /* ... and store info about transaction updating this tuple */
4126
4127 /* record address of new tuple in t_ctid of old one */
4129
4130 /* clear PD_ALL_VISIBLE flags, reset all visibilitymap bits */
4132 {
4133 all_visible_cleared = true;
4136 vmbuffer, VISIBILITYMAP_VALID_BITS);
4137 }
4139 {
4140 all_visible_cleared_new = true;
4143 vmbuffer_new, VISIBILITYMAP_VALID_BITS);
4144 }
4145
4146 if (newbuf != buffer)
4147 MarkBufferDirty(newbuf);
4148 MarkBufferDirty(buffer);
4149
4150 /* XLOG stuff */
4152 {
4153 XLogRecPtr recptr;
4154
4155 /*
4156 * For logical decoding we need combo CIDs to properly decode the
4157 * catalog.
4158 */
4160 {
4161 log_heap_new_cid(relation, &oldtup);
4162 log_heap_new_cid(relation, heaptup);
4163 }
4164
4165 recptr = log_heap_update(relation, buffer,
4166 newbuf, &oldtup, heaptup,
4167 old_key_tuple,
4168 all_visible_cleared,
4169 all_visible_cleared_new);
4170 if (newbuf != buffer)
4171 {
4173 }
4175 }
4176
4177 END_CRIT_SECTION();
4178
4179 if (newbuf != buffer)
4182
4183 /*
4184 * Mark old tuple for invalidation from system caches at next command
4185 * boundary, and mark the new tuple for invalidation in case we abort. We
4186 * have to do this before releasing the buffer because oldtup is in the
4187 * buffer. (heaptup is all in local memory, but it's necessary to process
4188 * both tuple versions in one call to inval.c so we can avoid redundant
4189 * sinval messages.)
4190 */
4191 CacheInvalidateHeapTuple(relation, &oldtup, heaptup);
4192
4193 /* Now we can release the buffer(s) */
4194 if (newbuf != buffer)
4195 ReleaseBuffer(newbuf);
4196 ReleaseBuffer(buffer);
4198 ReleaseBuffer(vmbuffer_new);
4200 ReleaseBuffer(vmbuffer);
4201
4202 /*
4203 * Release the lmgr tuple lock, if we had it.
4204 */
4205 if (have_tuple_lock)
4207
4208 pgstat_count_heap_update(relation, use_hot_update, newbuf != buffer);
4209
4210 /*
4211 * If heaptup is a private copy, release it. Don't forget to copy t_self
4212 * back to the caller's image, too.
4213 */
4214 if (heaptup != newtup)
4215 {
4217 heap_freetuple(heaptup);
4218 }
4219
4220 /*
4221 * If it is a HOT update, the update may still need to update summarized
4222 * indexes, lest we fail to update those summaries and get incorrect
4223 * results (for example, minmax bounds of the block may change with this
4224 * update).
4225 */
4226 if (use_hot_update)
4227 {
4228 if (summarized_update)
4229 *update_indexes = TU_Summarizing;
4230 else
4231 *update_indexes = TU_None;
4232 }
4233 else
4234 *update_indexes = TU_All;
4235
4236 if (old_key_tuple != NULL && old_key_copied)
4237 heap_freetuple(old_key_tuple);
4238
4239 bms_free(hot_attrs);
4240 bms_free(sum_attrs);
4241 bms_free(key_attrs);
4242 bms_free(id_attrs);
4243 bms_free(modified_attrs);
4244 bms_free(interesting_attrs);
4245
4247}
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:916
static Bitmapset * HeapDetermineColumnsInfo(Relation relation, Bitmapset *interesting_cols, Bitmapset *external_cols, HeapTuple oldtup, HeapTuple newtup, bool *has_external)
Definition: heapam.c:4427
static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf, Buffer newbuf, HeapTuple oldtup, HeapTuple newtup, HeapTuple old_key_tuple, bool all_visible_cleared, bool new_all_visible_cleared)
Definition: heapam.c:8864
TransactionId HeapTupleGetUpdateXid(const HeapTupleHeaderData *tup)
Definition: heapam.c:7605
static void HeapTupleClearHotUpdated(const HeapTupleData *tuple)
Definition: htup_details.h:780
static void HeapTupleSetHeapOnly(const HeapTupleData *tuple)
Definition: htup_details.h:792
static void HeapTupleSetHotUpdated(const HeapTupleData *tuple)
Definition: htup_details.h:774
static void HeapTupleClearHeapOnly(const HeapTupleData *tuple)
Definition: htup_details.h:798
void pgstat_count_heap_update(Relation rel, bool hot, bool newpage)
Definition: pgstat_relation.c:389
References Assert(), AssertHasSnapshotForToast(), bms_add_members(), bms_free(), bms_overlap(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), CacheInvalidateHeapTuple(), CheckForSerializableConflictIn(), TM_FailureData::cmax, compute_infobits(), compute_new_xmax_infomask(), TM_FailureData::ctid, DoesMultiXactIdConflict(), END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, ExtractReplicaIdentity(), xl_heap_lock::flags, GetCurrentTransactionId(), GetMultiXactIdHintBits(), HEAP2_XACT_MASK, heap_acquire_tuplock(), heap_freetuple(), HEAP_LOCKED_UPGRADED(), HEAP_MOVED, heap_toast_insert_or_update(), HEAP_UPDATED, HEAP_XACT_MASK, HEAP_XMAX_BITS, HEAP_XMAX_INVALID, HEAP_XMAX_IS_KEYSHR_LOCKED(), HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMAX_KEYSHR_LOCK, HEAP_XMAX_LOCK_ONLY, HeapDetermineColumnsInfo(), HeapTupleClearHeapOnly(), HeapTupleClearHotUpdated(), HeapTupleGetUpdateXid(), HeapTupleHasExternal(), HeapTupleHeaderAdjustCmax(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetNatts, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderSetCmax(), HeapTupleHeaderSetCmin(), HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVisibility(), HeapTupleSetHeapOnly(), HeapTupleSetHotUpdated(), INDEX_ATTR_BITMAP_HOT_BLOCKING, INDEX_ATTR_BITMAP_IDENTITY_KEY, INDEX_ATTR_BITMAP_KEY, INDEX_ATTR_BITMAP_SUMMARIZED, xl_heap_lock::infobits_set, INJECTION_POINT, InvalidBuffer, InvalidCommandId, InvalidSnapshot, InvalidTransactionId, IsInParallelMode(), ItemIdGetLength, ItemIdIsNormal, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), LockTupleExclusive, LockTupleNoKeyExclusive, LockWaitBlock, log_heap_new_cid(), log_heap_update(), MarkBufferDirty(), MAXALIGN, MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusNoKeyUpdate, MultiXactStatusUpdate, xl_heap_lock::offnum, PageClearAllVisible(), PageGetHeapFreeSpace(), PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetFull(), PageSetLSN(), PageSetPrunable, pgstat_count_heap_update(), RelationData::rd_rel, ReadBuffer(), REGBUF_STANDARD, RelationGetBufferForTuple(), RelationGetIndexAttrBitmap(), RelationGetNumberOfAttributes, RelationGetRelid, RelationIsAccessibleInLogicalDecoding, RelationNeedsWAL, RelationPutHeapTuple(), RelationSupportsSysCache(), ReleaseBuffer(), SizeOfHeapLock, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TM_BeingModified, TM_Deleted, TM_Invisible, TM_Ok, TM_SelfModified, TM_Updated, TOAST_TUPLE_THRESHOLD, TransactionIdDidAbort(), TransactionIdEquals, TransactionIdIsCurrentTransactionId(), TransactionIdIsValid, TU_All, TU_None, TU_Summarizing, UnlockReleaseBuffer(), UnlockTupleTuplock, UpdateXmaxHintBits(), VISIBILITYMAP_ALL_FROZEN, visibilitymap_clear(), visibilitymap_pin(), VISIBILITYMAP_VALID_BITS, XactLockTableWait(), XLH_LOCK_ALL_FROZEN_CLEARED, XLOG_HEAP_LOCK, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), XLTW_Update, xl_heap_lock::xmax, TM_FailureData::xmax, and xmax_infomask_changed().
Referenced by heapam_tuple_update(), and simple_heap_update().
◆ HeapCheckForSerializableConflictOut()
| void HeapCheckForSerializableConflictOut | ( | bool | visible, |
| Relation | relation, | ||
| HeapTuple | tuple, | ||
| Buffer | buffer, | ||
| Snapshot | snapshot | ||
| ) |
Definition at line 9271 of file heapam.c.
9274{
9275 TransactionId xid;
9276 HTSV_Result htsvResult;
9277
9279 return;
9280
9281 /*
9282 * Check to see whether the tuple has been written to by a concurrent
9283 * transaction, either to create it not visible to us, or to delete it
9284 * while it is visible to us. The "visible" bool indicates whether the
9285 * tuple is visible to us, while HeapTupleSatisfiesVacuum checks what else
9286 * is going on with it.
9287 *
9288 * In the event of a concurrently inserted tuple that also happens to have
9289 * been concurrently updated (by a separate transaction), the xmin of the
9290 * tuple will be used -- not the updater's xid.
9291 */
9293 switch (htsvResult)
9294 {
9296 if (visible)
9297 return;
9299 break;
9302 if (visible)
9304 else
9306
9308 {
9309 /* This is like the HEAPTUPLE_DEAD case */
9310 Assert(!visible);
9311 return;
9312 }
9313 break;
9316 break;
9318 Assert(!visible);
9319 return;
9320 default:
9321
9322 /*
9323 * The only way to get to this default clause is if a new value is
9324 * added to the enum type without adding it to this switch
9325 * statement. That's a bug, so elog.
9326 */
9328
9329 /*
9330 * In spite of having all enum values covered and calling elog on
9331 * this default, some compilers think this is a code path which
9332 * allows xid to be used below without initialization. Silence
9333 * that warning.
9334 */
9335 xid = InvalidTransactionId;
9336 }
9337
9340
9341 /*
9342 * Find top level xid. Bail out if xid is too early to be a conflict, or
9343 * if it's our own xid.
9344 */
9346 return;
9347 xid = SubTransGetTopmostTransaction(xid);
9349 return;
9350
9351 CheckForSerializableConflictOut(relation, xid, snapshot);
9352}
HTSV_Result HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin, Buffer buffer)
Definition: heapam_visibility.c:1171
void CheckForSerializableConflictOut(Relation relation, TransactionId xid, Snapshot snapshot)
Definition: predicate.c:4023
TransactionId SubTransGetTopmostTransaction(TransactionId xid)
Definition: subtrans.c:162
static bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
Definition: transam.h:312
References Assert(), CheckForSerializableConflictOut(), CheckForSerializableConflictOutNeeded(), elog, ERROR, GetTopTransactionIdIfAny(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleSatisfiesVacuum(), InvalidTransactionId, SubTransGetTopmostTransaction(), HeapTupleData::t_data, TransactionIdEquals, TransactionIdFollowsOrEquals(), TransactionIdIsValid, TransactionIdPrecedes(), and TransactionXmin.
Referenced by BitmapHeapScanNextBlock(), heap_fetch(), heap_get_latest_tid(), heap_hot_search_buffer(), heapam_scan_sample_next_tuple(), heapgettup(), and page_collect_tuples().
◆ HeapDetermineColumnsInfo()
|
static |
Definition at line 4427 of file heapam.c.
4432{
4433 int attidx;
4434 Bitmapset *modified = NULL;
4436
4437 attidx = -1;
4439 {
4440 /* attidx is zero-based, attrnum is the normal attribute number */
4442 Datum value1,
4443 value2;
4444 bool isnull1,
4445 isnull2;
4446
4447 /*
4448 * If it's a whole-tuple reference, say "not equal". It's not really
4449 * worth supporting this case, since it could only succeed after a
4450 * no-op update, which is hardly a case worth optimizing for.
4451 */
4452 if (attrnum == 0)
4453 {
4454 modified = bms_add_member(modified, attidx);
4455 continue;
4456 }
4457
4458 /*
4459 * Likewise, automatically say "not equal" for any system attribute
4460 * other than tableOID; we cannot expect these to be consistent in a
4461 * HOT chain, or even to be set correctly yet in the new tuple.
4462 */
4463 if (attrnum < 0)
4464 {
4466 {
4467 modified = bms_add_member(modified, attidx);
4468 continue;
4469 }
4470 }
4471
4472 /*
4473 * Extract the corresponding values. XXX this is pretty inefficient
4474 * if there are many indexed columns. Should we do a single
4475 * heap_deform_tuple call on each tuple, instead? But that doesn't
4476 * work for system columns ...
4477 */
4478 value1 = heap_getattr(oldtup, attrnum, tupdesc, &isnull1);
4479 value2 = heap_getattr(newtup, attrnum, tupdesc, &isnull2);
4480
4482 value2, isnull1, isnull2))
4483 {
4484 modified = bms_add_member(modified, attidx);
4485 continue;
4486 }
4487
4488 /*
4489 * No need to check attributes that can't be stored externally. Note
4490 * that system attributes can't be stored externally.
4491 */
4492 if (attrnum < 0 || isnull1 ||
4494 continue;
4495
4496 /*
4497 * Check if the old tuple's attribute is stored externally and is a
4498 * member of external_cols.
4499 */
4501 bms_is_member(attidx, external_cols))
4502 *has_external = true;
4503 }
4504
4505 return modified;
4506}
static bool heap_attr_equals(TupleDesc tupdesc, int attrnum, Datum value1, Datum value2, bool isnull1, bool isnull2)
Definition: heapam.c:4376
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:904
References attlen, bms_add_member(), bms_is_member(), bms_next_member(), DatumGetPointer(), FirstLowInvalidHeapAttributeNumber, heap_attr_equals(), heap_getattr(), RelationGetDescr, TableOidAttributeNumber, TupleDescCompactAttr(), and VARATT_IS_EXTERNAL().
Referenced by heap_update().
◆ heapgettup()
|
static |
Definition at line 911 of file heapam.c.
915{
917 Page page;
918 OffsetNumber lineoff;
919 int linesleft;
920
922 {
923 /* continue from previously returned page/tuple */
925 page = heapgettup_continue_page(scan, dir, &linesleft, &lineoff);
926 goto continue_page;
927 }
928
929 /*
930 * advance the scan until we find a qualifying tuple or run out of stuff
931 * to scan
932 */
933 while (true)
934 {
935 heap_fetch_next_buffer(scan, dir);
936
937 /* did we run out of blocks to scan? */
939 break;
940
942
944 page = heapgettup_start_page(scan, dir, &linesleft, &lineoff);
945continue_page:
946
947 /*
948 * Only continue scanning the page while we have lines left.
949 *
950 * Note that this protects us from accessing line pointers past
951 * PageGetMaxOffsetNumber(); both for forward scans when we resume the
952 * table scan, and for when we start scanning a new page.
953 */
954 for (; linesleft > 0; linesleft--, lineoff += dir)
955 {
956 bool visible;
958
960 continue;
961
965
966 visible = HeapTupleSatisfiesVisibility(tuple,
968 scan->rs_cbuf);
969
971 tuple, scan->rs_cbuf,
973
974 /* skip tuples not visible to this snapshot */
975 if (!visible)
976 continue;
977
978 /* skip any tuples that don't match the scan key */
981 nkeys, key))
982 continue;
983
985 scan->rs_coffset = lineoff;
986 return;
987 }
988
989 /*
990 * if we get here, it means we've exhausted the items on this page and
991 * it's time to move to the next.
992 */
994 }
995
996 /* end of scan */
999
1003 tuple->t_data = NULL;
1005}
static void heap_fetch_next_buffer(HeapScanDesc scan, ScanDirection dir)
Definition: heapam.c:658
static Page heapgettup_continue_page(HeapScanDesc scan, ScanDirection dir, int *linesleft, OffsetNumber *lineoff)
Definition: heapam.c:781
static Page heapgettup_start_page(HeapScanDesc scan, ScanDirection dir, int *linesleft, OffsetNumber *lineoff)
Definition: heapam.c:750
static bool HeapKeyTest(HeapTuple tuple, TupleDesc tupdesc, int nkeys, ScanKey keys)
Definition: valid.h:28
References Assert(), BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferIsValid(), heap_fetch_next_buffer(), HeapCheckForSerializableConflictOut(), heapgettup_continue_page(), heapgettup_start_page(), HeapKeyTest(), HeapTupleSatisfiesVisibility(), InvalidBlockNumber, InvalidBuffer, ItemIdGetLength, ItemIdIsNormal, ItemPointerSet(), sort-test::key, likely, LockBuffer(), PageGetItem(), PageGetItemId(), RelationGetDescr, ReleaseBuffer(), HeapScanDescData::rs_base, HeapScanDescData::rs_cblock, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_coffset, HeapScanDescData::rs_ctup, HeapScanDescData::rs_inited, HeapScanDescData::rs_prefetch_block, TableScanDescData::rs_rd, TableScanDescData::rs_snapshot, HeapTupleData::t_data, HeapTupleData::t_len, and HeapTupleData::t_self.
Referenced by heap_getnext(), heap_getnextslot(), and heap_getnextslot_tidrange().
◆ heapgettup_advance_block()
|
inlinestatic |
Definition at line 827 of file heapam.c.
828{
830
832 {
833 block++;
834
835 /* wrap back to the start of the heap */
837 block = 0;
838
839 /*
840 * Report our new scan position for synchronization purposes. We don't
841 * do that when moving backwards, however. That would just mess up any
842 * other forward-moving scanners.
843 *
844 * Note: we do this before checking for end of scan so that the final
845 * state of the position hint is back at the start of the rel. That's
846 * not strictly necessary, but otherwise when you run the same query
847 * multiple times the starting position would shift a little bit
848 * backwards on every invocation, which is confusing. We don't
849 * guarantee any specific ordering in general, though.
850 */
853
854 /* we're done if we're back at where we started */
857
858 /* check if the limit imposed by heap_setscanlimits() is met */
860 {
863 }
864
865 return block;
866 }
867 else
868 {
869 /* we're done if the last block is the start position */
872
873 /* check if the limit imposed by heap_setscanlimits() is met */
875 {
878 }
879
880 /* wrap to the end of the heap when the last page was page 0 */
881 if (block == 0)
882 block = scan->rs_nblocks;
883
884 block--;
885
886 return block;
887 }
888}
void ss_report_location(Relation rel, BlockNumber location)
Definition: syncscan.c:289
References Assert(), InvalidBlockNumber, likely, HeapScanDescData::rs_base, TableScanDescData::rs_flags, HeapScanDescData::rs_nblocks, HeapScanDescData::rs_numblocks, TableScanDescData::rs_parallel, TableScanDescData::rs_rd, HeapScanDescData::rs_startblock, ScanDirectionIsForward, SO_ALLOW_SYNC, and ss_report_location().
Referenced by heap_scan_stream_read_next_serial().
◆ heapgettup_continue_page()
|
inlinestatic |
Definition at line 781 of file heapam.c.
783{
784 Page page;
785
788
789 /* Caller is responsible for ensuring buffer is locked if needed */
791
793 {
795 *linesleft = PageGetMaxOffsetNumber(page) - (*lineoff) + 1;
796 }
797 else
798 {
799 /*
800 * The previous returned tuple may have been vacuumed since the
801 * previous scan when we use a non-MVCC snapshot, so we must
802 * re-establish the lineoff <= PageGetMaxOffsetNumber(page) invariant
803 */
805 *linesleft = *lineoff;
806 }
807
808 /* lineoff now references the physically previous or next tid */
809 return page;
810}
References Assert(), BufferGetPage(), BufferIsValid(), Min, OffsetNumberNext, OffsetNumberPrev, PageGetMaxOffsetNumber(), HeapScanDescData::rs_cbuf, HeapScanDescData::rs_coffset, HeapScanDescData::rs_inited, and ScanDirectionIsForward.
Referenced by heapgettup().
◆ heapgettup_initial_block()
|
static |
Definition at line 703 of file heapam.c.
704{
707
708 /* When there are no pages to scan, return InvalidBlockNumber */
711
713 {
715 }
716 else
717 {
718 /*
719 * Disable reporting to syncscan logic in a backwards scan; it's not
720 * very likely anyone else is doing the same thing at the same time,
721 * and much more likely that we'll just bollix things for forward
722 * scanners.
723 */
725
726 /*
727 * Start from last page of the scan. Ensure we take into account
728 * rs_numblocks if it's been adjusted by heap_setscanlimits().
729 */
732
735
737 }
738}
References Assert(), InvalidBlockNumber, HeapScanDescData::rs_base, TableScanDescData::rs_flags, HeapScanDescData::rs_inited, HeapScanDescData::rs_nblocks, HeapScanDescData::rs_numblocks, TableScanDescData::rs_parallel, HeapScanDescData::rs_startblock, and ScanDirectionIsForward.
Referenced by heap_scan_stream_read_next_serial().
◆ heapgettup_pagemode()
|
static |
Definition at line 1021 of file heapam.c.
1025{
1027 Page page;
1028 uint32 lineindex;
1029 uint32 linesleft;
1030
1032 {
1033 /* continue from previously returned page/tuple */
1035
1036 lineindex = scan->rs_cindex + dir;
1038 linesleft = scan->rs_ntuples - lineindex;
1039 else
1040 linesleft = scan->rs_cindex;
1041 /* lineindex now references the next or previous visible tid */
1042
1043 goto continue_page;
1044 }
1045
1046 /*
1047 * advance the scan until we find a qualifying tuple or run out of stuff
1048 * to scan
1049 */
1050 while (true)
1051 {
1052 heap_fetch_next_buffer(scan, dir);
1053
1054 /* did we run out of blocks to scan? */
1056 break;
1057
1059
1060 /* prune the page and determine visible tuple offsets */
1063 linesleft = scan->rs_ntuples;
1064 lineindex = ScanDirectionIsForward(dir) ? 0 : linesleft - 1;
1065
1066 /* block is the same for all tuples, set it once outside the loop */
1068
1069 /* lineindex now references the next or previous visible tid */
1070continue_page:
1071
1072 for (; linesleft > 0; linesleft--, lineindex += dir)
1073 {
1074 ItemId lpp;
1075 OffsetNumber lineoff;
1076
1077 Assert(lineindex <= scan->rs_ntuples);
1078 lineoff = scan->rs_vistuples[lineindex];
1079 lpp = PageGetItemId(page, lineoff);
1081
1085
1086 /* skip any tuples that don't match the scan key */
1089 nkeys, key))
1090 continue;
1091
1092 scan->rs_cindex = lineindex;
1093 return;
1094 }
1095 }
1096
1097 /* end of scan */
1103 tuple->t_data = NULL;
1105}
static void ItemPointerSetBlockNumber(ItemPointerData *pointer, BlockNumber blockNumber)
Definition: itemptr.h:147
OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]
Definition: heapam.h:100
References Assert(), BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), heap_fetch_next_buffer(), heap_prepare_pagescan(), HeapKeyTest(), InvalidBlockNumber, InvalidBuffer, ItemIdGetLength, ItemIdIsNormal, ItemPointerSetBlockNumber(), ItemPointerSetOffsetNumber(), sort-test::key, likely, PageGetItem(), PageGetItemId(), RelationGetDescr, ReleaseBuffer(), HeapScanDescData::rs_cblock, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_cindex, HeapScanDescData::rs_ctup, HeapScanDescData::rs_inited, HeapScanDescData::rs_ntuples, HeapScanDescData::rs_prefetch_block, TableScanDescData::rs_rd, ScanDirectionIsForward, HeapTupleData::t_data, HeapTupleData::t_len, and HeapTupleData::t_self.
Referenced by heap_getnext(), heap_getnextslot(), and heap_getnextslot_tidrange().
◆ heapgettup_start_page()
|
static |
Definition at line 750 of file heapam.c.
752{
753 Page page;
754
757
758 /* Caller is responsible for ensuring buffer is locked if needed */
760
762
764 *lineoff = FirstOffsetNumber;
765 else
766 *lineoff = (OffsetNumber) (*linesleft);
767
768 /* lineoff now references the physically previous or next tid */
769 return page;
770}
References Assert(), BufferGetPage(), BufferIsValid(), FirstOffsetNumber, PageGetMaxOffsetNumber(), HeapScanDescData::rs_cbuf, HeapScanDescData::rs_inited, and ScanDirectionIsForward.
Referenced by heapgettup().
◆ HeapTupleGetUpdateXid()
| TransactionId HeapTupleGetUpdateXid | ( | const HeapTupleHeaderData * | tup | ) |
Definition at line 7605 of file heapam.c.
References HeapTupleHeaderGetRawXmax(), MultiXactIdGetUpdateXid(), and HeapTupleHeaderData::t_infomask.
Referenced by check_tuple_visibility(), heap_update(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesUpdate(), and HeapTupleSatisfiesVacuumHorizon().
◆ HeapTupleHeaderAdvanceConflictHorizon()
| void HeapTupleHeaderAdvanceConflictHorizon | ( | HeapTupleHeader | tuple, |
| TransactionId * | snapshotConflictHorizon | ||
| ) |
Definition at line 7999 of file heapam.c.
8001{
8005
8007 {
8009 *snapshotConflictHorizon = xvac;
8010 }
8011
8012 /*
8013 * Ignore tuples inserted by an aborted transaction or if the tuple was
8014 * updated/deleted by the inserting transaction.
8015 *
8016 * Look for a committed hint bit, or if no xmin bit is set, check clog.
8017 */
8020 {
8021 if (xmax != xmin &&
8022 TransactionIdFollows(xmax, *snapshotConflictHorizon))
8023 *snapshotConflictHorizon = xmax;
8024 }
8025}
static bool HeapTupleHeaderXminInvalid(const HeapTupleHeaderData *tup)
Definition: htup_details.h:343
static bool HeapTupleHeaderXminCommitted(const HeapTupleHeaderData *tup)
Definition: htup_details.h:337
static bool TransactionIdFollows(TransactionId id1, TransactionId id2)
Definition: transam.h:297
References HEAP_MOVED, HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderGetXvac(), HeapTupleHeaderXminCommitted(), HeapTupleHeaderXminInvalid(), HeapTupleHeaderData::t_infomask, TransactionIdDidCommit(), TransactionIdFollows(), and TransactionIdPrecedes().
Referenced by heap_index_delete_tuples(), heap_prune_chain(), and prune_freeze_plan().
◆ index_delete_check_htid()
|
inlinestatic |
Definition at line 8084 of file heapam.c.
8087{
8089 ItemId iid;
8090
8092
8095 (errcode(ERRCODE_INDEX_CORRUPTED),
8096 errmsg_internal("heap tid from index tuple (%u,%u) points past end of heap page line pointer array at offset %u of block %u in index \"%s\"",
8097 ItemPointerGetBlockNumber(htid),
8098 indexpagehoffnum,
8101
8102 iid = PageGetItemId(page, indexpagehoffnum);
8105 (errcode(ERRCODE_INDEX_CORRUPTED),
8106 errmsg_internal("heap tid from index tuple (%u,%u) points to unused heap page item at offset %u of block %u in index \"%s\"",
8107 ItemPointerGetBlockNumber(htid),
8108 indexpagehoffnum,
8111
8113 {
8114 HeapTupleHeader htup;
8115
8118
8121 (errcode(ERRCODE_INDEX_CORRUPTED),
8122 errmsg_internal("heap tid from index tuple (%u,%u) points to heap-only tuple at offset %u of block %u in index \"%s\"",
8123 ItemPointerGetBlockNumber(htid),
8124 indexpagehoffnum,
8127 }
8128}
References Assert(), ereport, errcode(), errmsg_internal(), ERROR, HeapTupleHeaderIsHeapOnly(), TM_IndexDeleteOp::iblknum, TM_IndexStatus::idxoffnum, TM_IndexDeleteOp::irel, ItemIdHasStorage, ItemIdIsNormal, ItemIdIsUsed, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), OffsetNumberIsValid, PageGetItem(), PageGetItemId(), RelationGetRelationName, and unlikely.
Referenced by heap_index_delete_tuples().
◆ index_delete_sort()
|
static |
Definition at line 8489 of file heapam.c.
8490{
8493
8494 /*
8495 * Shellsort gap sequence (taken from Sedgewick-Incerpi paper).
8496 *
8497 * This implementation is fast with array sizes up to ~4500. This covers
8498 * all supported BLCKSZ values.
8499 */
8500 const int gaps[9] = {1968, 861, 336, 112, 48, 21, 7, 3, 1};
8501
8502 /* Think carefully before changing anything here -- keep swaps cheap */
8504 "element size exceeds 8 bytes");
8505
8507 {
8509 {
8512
8514 {
8516 j -= hi;
8517 }
8518 deltids[j] = d;
8519 }
8520 }
8521}
static int index_delete_sort_cmp(TM_IndexDelete *deltid1, TM_IndexDelete *deltid2)
Definition: heapam.c:8453
References TM_IndexDeleteOp::deltids, i, index_delete_sort_cmp(), j, lengthof, TM_IndexDeleteOp::ndeltids, and StaticAssertDecl.
Referenced by heap_index_delete_tuples().
◆ index_delete_sort_cmp()
|
inlinestatic |
Definition at line 8453 of file heapam.c.
8454{
8457
8458 {
8461
8462 if (blk1 != blk2)
8463 return (blk1 < blk2) ? -1 : 1;
8464 }
8465 {
8468
8469 if (pos1 != pos2)
8470 return (pos1 < pos2) ? -1 : 1;
8471 }
8472
8474
8475 return 0;
8476}
References Assert(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), and TM_IndexDelete::tid.
Referenced by index_delete_sort().
◆ initscan()
|
static |
Definition at line 352 of file heapam.c.
353{
354 ParallelBlockTableScanDesc bpscan = NULL;
355 bool allow_strat;
356 bool allow_sync;
357
358 /*
359 * Determine the number of blocks we have to scan.
360 *
361 * It is sufficient to do this once at scan start, since any tuples added
362 * while the scan is in progress will be invisible to my snapshot anyway.
363 * (That is not true when using a non-MVCC snapshot. However, we couldn't
364 * guarantee to return tuples added after scan start anyway, since they
365 * might go into pages we already scanned. To guarantee consistent
366 * results for a non-MVCC snapshot, the caller must hold some higher-level
367 * lock that ensures the interesting tuple(s) won't change.)
368 */
370 {
373 }
374 else
376
377 /*
378 * If the table is large relative to NBuffers, use a bulk-read access
379 * strategy and enable synchronized scanning (see syncscan.c). Although
380 * the thresholds for these features could be different, we make them the
381 * same so that there are only two behaviors to tune rather than four.
382 * (However, some callers need to be able to disable one or both of these
383 * behaviors, independently of the size of the table; also there is a GUC
384 * variable that can disable synchronized scanning.)
385 *
386 * Note that table_block_parallelscan_initialize has a very similar test;
387 * if you change this, consider changing that one, too.
388 */
391 {
394 }
395 else
396 allow_strat = allow_sync = false;
397
398 if (allow_strat)
399 {
400 /* During a rescan, keep the previous strategy object. */
403 }
404 else
405 {
408 scan->rs_strategy = NULL;
409 }
410
412 {
413 /* For parallel scan, believe whatever ParallelTableScanDesc says. */
416 else
418
419 /*
420 * If not rescanning, initialize the startblock. Finding the actual
421 * start location is done in table_block_parallelscan_startblock_init,
422 * based on whether an alternative start location has been set with
423 * heap_setscanlimits, or using the syncscan location, when syncscan
424 * is enabled.
425 */
426 if (!keep_startblock)
428 }
429 else
430 {
431 if (keep_startblock)
432 {
433 /*
434 * When rescanning, we want to keep the previous startblock
435 * setting, so that rewinding a cursor doesn't generate surprising
436 * results. Reset the active syncscan setting, though.
437 */
440 else
442 }
444 {
447 }
448 else
449 {
451 scan->rs_startblock = 0;
452 }
453 }
454
461 scan->rs_ntuples = 0;
462 scan->rs_cindex = 0;
463
464 /*
465 * Initialize to ForwardScanDirection because it is most common and
466 * because heap scans go forward before going backward (e.g. CURSORs).
467 */
470
471 /* page-at-a-time fields are always invalid when not rs_inited */
472
473 /*
474 * copy the scan key, if appropriate
475 */
478
479 /*
480 * Currently, we only have a stats counter for sequential heap scans (but
481 * e.g for bitmap scans the underlying bitmap index scans will be counted,
482 * and for sample scans we update stats for tuple fetches).
483 */
486}
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition: itemptr.h:184
struct ParallelBlockTableScanDescData * ParallelBlockTableScanDesc
Definition: relscan.h:104
BlockNumber ss_get_location(Relation rel, BlockNumber relnblocks)
Definition: syncscan.c:254
References BAS_BULKREAD, ForwardScanDirection, FreeAccessStrategy(), GetAccessStrategy(), InvalidBlockNumber, InvalidBuffer, ItemPointerSetInvalid(), sort-test::key, NBuffers, pgstat_count_heap_scan, ParallelBlockTableScanDescData::phs_nblocks, ParallelTableScanDescData::phs_syncscan, RelationGetNumberOfBlocks, RelationUsesLocalBuffers, HeapScanDescData::rs_base, HeapScanDescData::rs_cblock, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_cindex, HeapScanDescData::rs_ctup, HeapScanDescData::rs_dir, TableScanDescData::rs_flags, HeapScanDescData::rs_inited, TableScanDescData::rs_key, HeapScanDescData::rs_nblocks, TableScanDescData::rs_nkeys, HeapScanDescData::rs_ntuples, HeapScanDescData::rs_numblocks, TableScanDescData::rs_parallel, HeapScanDescData::rs_prefetch_block, TableScanDescData::rs_rd, HeapScanDescData::rs_startblock, HeapScanDescData::rs_strategy, SO_ALLOW_STRAT, SO_ALLOW_SYNC, SO_TYPE_SEQSCAN, ss_get_location(), synchronize_seqscans, HeapTupleData::t_data, and HeapTupleData::t_self.
Referenced by heap_beginscan(), and heap_rescan().
◆ log_heap_new_cid()
|
static |
Definition at line 9086 of file heapam.c.
9087{
9088 xl_heap_new_cid xlrec;
9089
9090 XLogRecPtr recptr;
9092
9095
9099
9100 /*
9101 * If the tuple got inserted & deleted in the same TX we definitely have a
9102 * combo CID, set cmin and cmax.
9103 */
9105 {
9111 }
9112 /* No combo CID, so only cmin or cmax can be set by this TX */
9113 else
9114 {
9115 /*
9116 * Tuple inserted.
9117 *
9118 * We need to check for LOCK ONLY because multixacts might be
9119 * transferred to the new tuple in case of FOR KEY SHARE updates in
9120 * which case there will be an xmax, although the tuple just got
9121 * inserted.
9122 */
9125 {
9128 }
9129 /* Tuple from a different tx updated or deleted. */
9130 else
9131 {
9134 }
9136 }
9137
9138 /*
9139 * Note that we don't need to register the buffer here, because this
9140 * operation does not modify the page. The insert/update/delete that
9141 * called us certainly did, but that's WAL-logged separately.
9142 */
9143 XLogBeginInsert();
9145
9146 /* will be looked at irrespective of origin */
9147
9149
9150 return recptr;
9151}
CommandId HeapTupleHeaderGetCmin(const HeapTupleHeaderData *tup)
Definition: combocid.c:104
static CommandId HeapTupleHeaderGetRawCommandId(const HeapTupleHeaderData *tup)
Definition: htup_details.h:415
Definition: heapam_xlog.h:461
References Assert(), xl_heap_new_cid::cmax, xl_heap_new_cid::cmin, xl_heap_new_cid::combocid, GetTopTransactionId(), HEAP_COMBOCID, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetCmin(), HeapTupleHeaderGetRawCommandId(), HeapTupleHeaderXminInvalid(), InvalidCommandId, InvalidOid, ItemPointerIsValid(), RelationData::rd_locator, SizeOfHeapNewCid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleData::t_self, HeapTupleData::t_tableOid, xl_heap_new_cid::target_locator, xl_heap_new_cid::target_tid, xl_heap_new_cid::top_xid, XLOG_HEAP2_NEW_CID, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().
Referenced by heap_delete(), heap_insert(), heap_multi_insert(), and heap_update().
◆ log_heap_update()
|
static |
Definition at line 8864 of file heapam.c.
8868{
8869 xl_heap_update xlrec;
8870 xl_heap_header xlhdr;
8871 xl_heap_header xlhdr_idx;
8872 uint8 info;
8873 uint16 prefix_suffix[2];
8874 uint16 prefixlen = 0,
8875 suffixlen = 0;
8876 XLogRecPtr recptr;
8880 int bufflags;
8881
8882 /* Caller should not call me on a non-WAL-logged relation */
8884
8885 XLogBeginInsert();
8886
8888 info = XLOG_HEAP_HOT_UPDATE;
8889 else
8890 info = XLOG_HEAP_UPDATE;
8891
8892 /*
8893 * If the old and new tuple are on the same page, we only need to log the
8894 * parts of the new tuple that were changed. That saves on the amount of
8895 * WAL we need to write. Currently, we just count any unchanged bytes in
8896 * the beginning and end of the tuple. That's quick to check, and
8897 * perfectly covers the common case that only one field is updated.
8898 *
8899 * We could do this even if the old and new tuple are on different pages,
8900 * but only if we don't make a full-page image of the old page, which is
8901 * difficult to know in advance. Also, if the old tuple is corrupt for
8902 * some reason, it would allow the corruption to propagate the new page,
8903 * so it seems best to avoid. Under the general assumption that most
8904 * updates tend to create the new tuple version on the same page, there
8905 * isn't much to be gained by doing this across pages anyway.
8906 *
8907 * Skip this if we're taking a full-page image of the new page, as we
8908 * don't include the new tuple in the WAL record in that case. Also
8909 * disable if wal_level='logical', as logical decoding needs to be able to
8910 * read the new tuple in whole from the WAL record alone.
8911 */
8912 if (oldbuf == newbuf && !need_tuple_data &&
8913 !XLogCheckBufferNeedsBackup(newbuf))
8914 {
8919
8920 /* Check for common prefix between old and new tuple */
8922 {
8923 if (newp[prefixlen] != oldp[prefixlen])
8924 break;
8925 }
8926
8927 /*
8928 * Storing the length of the prefix takes 2 bytes, so we need to save
8929 * at least 3 bytes or there's no point.
8930 */
8931 if (prefixlen < 3)
8932 prefixlen = 0;
8933
8934 /* Same for suffix */
8936 {
8937 if (newp[newlen - suffixlen - 1] != oldp[oldlen - suffixlen - 1])
8938 break;
8939 }
8940 if (suffixlen < 3)
8941 suffixlen = 0;
8942 }
8943
8944 /* Prepare main WAL data chain */
8945 xlrec.flags = 0;
8946 if (all_visible_cleared)
8948 if (new_all_visible_cleared)
8950 if (prefixlen > 0)
8952 if (suffixlen > 0)
8954 if (need_tuple_data)
8955 {
8957 if (old_key_tuple)
8958 {
8961 else
8963 }
8964 }
8965
8966 /* If new tuple is the single and first tuple on page... */
8969 {
8970 info |= XLOG_HEAP_INIT_PAGE;
8972 }
8973 else
8975
8976 /* Prepare WAL data for the old page */
8981
8982 /* Prepare WAL data for the new page */
8985
8986 bufflags = REGBUF_STANDARD;
8988 bufflags |= REGBUF_WILL_INIT;
8989 if (need_tuple_data)
8990 bufflags |= REGBUF_KEEP_DATA;
8991
8992 XLogRegisterBuffer(0, newbuf, bufflags);
8993 if (oldbuf != newbuf)
8995
8997
8998 /*
8999 * Prepare WAL data for the new tuple.
9000 */
9001 if (prefixlen > 0 || suffixlen > 0)
9002 {
9003 if (prefixlen > 0 && suffixlen > 0)
9004 {
9005 prefix_suffix[0] = prefixlen;
9006 prefix_suffix[1] = suffixlen;
9008 }
9009 else if (prefixlen > 0)
9010 {
9012 }
9013 else
9014 {
9016 }
9017 }
9018
9023
9024 /*
9025 * PG73FORMAT: write bitmap [+ padding] [+ oid] + data
9026 *
9027 * The 'data' doesn't include the common prefix or suffix.
9028 */
9030 if (prefixlen == 0)
9031 {
9032 XLogRegisterBufData(0,
9035 }
9036 else
9037 {
9038 /*
9039 * Have to write the null bitmap and data after the common prefix as
9040 * two separate rdata entries.
9041 */
9042 /* bitmap [+ padding] [+ oid] */
9044 {
9045 XLogRegisterBufData(0,
9048 }
9049
9050 /* data after common prefix */
9051 XLogRegisterBufData(0,
9054 }
9055
9056 /* We need to log a tuple identity */
9057 if (need_tuple_data && old_key_tuple)
9058 {
9059 /* don't really need this, but its more comfy to decode */
9063
9065
9066 /* PG73FORMAT: write bitmap [+ padding] [+ oid] + data */
9069 }
9070
9071 /* filtering by origin on a row level is much more efficient */
9073
9074 recptr = XLogInsert(RM_HEAP_ID, info);
9075
9076 return recptr;
9077}
#define XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED
Definition: heapam_xlog.h:87
#define XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED
Definition: heapam_xlog.h:85
Definition: heapam_xlog.h:219
bool XLogCheckBufferNeedsBackup(Buffer buffer)
Definition: xloginsert.c:1049
References Assert(), BufferGetPage(), compute_infobits(), FirstOffsetNumber, xl_heap_update::flags, HeapTupleHeaderGetRawXmax(), HeapTupleIsHeapOnly(), init, ItemPointerGetOffsetNumber(), Min, xl_heap_update::new_offnum, xl_heap_update::new_xmax, xl_heap_update::old_infobits_set, xl_heap_update::old_offnum, xl_heap_update::old_xmax, PageGetMaxOffsetNumber(), RelationData::rd_rel, REGBUF_KEEP_DATA, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationIsLogicallyLogged, RelationNeedsWAL, SizeOfHeapHeader, SizeofHeapTupleHeader, SizeOfHeapUpdate, HeapTupleData::t_data, xl_heap_header::t_hoff, HeapTupleHeaderData::t_hoff, xl_heap_header::t_infomask, HeapTupleHeaderData::t_infomask, xl_heap_header::t_infomask2, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, XLH_UPDATE_CONTAINS_NEW_TUPLE, XLH_UPDATE_CONTAINS_OLD_KEY, XLH_UPDATE_CONTAINS_OLD_TUPLE, XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED, XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED, XLH_UPDATE_PREFIX_FROM_OLD, XLH_UPDATE_SUFFIX_FROM_OLD, XLOG_HEAP_HOT_UPDATE, XLOG_HEAP_INIT_PAGE, XLOG_HEAP_UPDATE, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogCheckBufferNeedsBackup(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), XLogRegisterData(), and XLogSetRecordFlags().
Referenced by heap_update().
◆ log_heap_visible()
| XLogRecPtr log_heap_visible | ( | Relation | rel, |
| Buffer | heap_buffer, | ||
| Buffer | vm_buffer, | ||
| TransactionId | snapshotConflictHorizon, | ||
| uint8 | vmflags | ||
| ) |
Definition at line 8830 of file heapam.c.
8832{
8833 xl_heap_visible xlrec;
8834 XLogRecPtr recptr;
8835 uint8 flags;
8836
8839
8840 xlrec.snapshotConflictHorizon = snapshotConflictHorizon;
8841 xlrec.flags = vmflags;
8844 XLogBeginInsert();
8846
8847 XLogRegisterBuffer(0, vm_buffer, 0);
8848
8849 flags = REGBUF_STANDARD;
8851 flags |= REGBUF_NO_IMAGE;
8852 XLogRegisterBuffer(1, heap_buffer, flags);
8853
8855
8856 return recptr;
8857}
Definition: heapam_xlog.h:453
TransactionId snapshotConflictHorizon
Definition: heapam_xlog.h:454
#define VISIBILITYMAP_XLOG_CATALOG_REL
Definition: visibilitymapdefs.h:30
References Assert(), BufferIsValid(), xl_heap_visible::flags, REGBUF_NO_IMAGE, REGBUF_STANDARD, RelationIsAccessibleInLogicalDecoding, SizeOfHeapVisible, xl_heap_visible::snapshotConflictHorizon, VISIBILITYMAP_XLOG_CATALOG_REL, XLOG_HEAP2_VISIBLE, XLogBeginInsert(), XLogHintBitIsNeeded, XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().
Referenced by visibilitymap_set().
◆ MultiXactIdGetUpdateXid()
|
static |
Definition at line 7553 of file heapam.c.
7554{
7556 MultiXactMember *members;
7557 int nmembers;
7558
7561
7562 /*
7563 * Since we know the LOCK_ONLY bit is not set, this cannot be a multi from
7564 * pre-pg_upgrade.
7565 */
7567
7568 if (nmembers > 0)
7569 {
7571
7573 {
7574 /* Ignore lockers */
7576 continue;
7577
7578 /* there can be at most one updater */
7581#ifndef USE_ASSERT_CHECKING
7582
7583 /*
7584 * in an assert-enabled build, walk the whole array to ensure
7585 * there's no other updater.
7586 */
7587 break;
7588#endif
7589 }
7590
7591 pfree(members);
7592 }
7593
7594 return update_xact;
7595}
References Assert(), GetMultiXactIdMembers(), HEAP_XMAX_IS_MULTI, HEAP_XMAX_LOCK_ONLY, i, InvalidTransactionId, ISUPDATE_from_mxstatus, pfree(), and MultiXactMember::xid.
Referenced by compute_new_xmax_infomask(), FreezeMultiXactId(), and HeapTupleGetUpdateXid().
◆ MultiXactIdWait()
|
static |
Definition at line 7799 of file heapam.c.
7802{
7805}
References Do_MultiXactIdWait(), oper(), and remaining.
Referenced by heap_delete(), heap_inplace_lock(), heap_lock_tuple(), and heap_update().
◆ page_collect_tuples()
|
static |
Definition at line 517 of file heapam.c.
521{
522 int ntup = 0;
523 OffsetNumber lineoff;
524
526 {
528 HeapTupleData loctup;
529 bool valid;
530
532 continue;
533
538
539 if (all_visible)
540 valid = true;
541 else
542 valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
543
544 if (check_serializable)
546 &loctup, buffer, snapshot);
547
548 if (valid)
549 {
550 scan->rs_vistuples[ntup] = lineoff;
551 ntup++;
552 }
553 }
554
556
557 return ntup;
558}
References Assert(), FirstOffsetNumber, HeapCheckForSerializableConflictOut(), HeapTupleSatisfiesVisibility(), ItemIdGetLength, ItemIdIsNormal, ItemPointerSet(), MaxHeapTuplesPerPage, PageGetItem(), PageGetItemId(), RelationGetRelid, HeapScanDescData::rs_base, TableScanDescData::rs_rd, HeapScanDescData::rs_vistuples, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.
Referenced by heap_prepare_pagescan().
◆ ReleaseBulkInsertStatePin()
| void ReleaseBulkInsertStatePin | ( | BulkInsertState | bistate | ) |
Definition at line 2065 of file heapam.c.
2066{
2070
2071 /*
2072 * Despite the name, we also reset bulk relation extension state.
2073 * Otherwise we can end up erroring out due to looking for free space in
2074 * ->next_free of one partition, even though ->next_free was set when
2075 * extending another partition. It could obviously also be bad for
2076 * efficiency to look at existing blocks at offsets from another
2077 * partition, even if we don't error out.
2078 */
2081}
References BulkInsertStateData::current_buf, InvalidBlockNumber, InvalidBuffer, BulkInsertStateData::last_free, BulkInsertStateData::next_free, and ReleaseBuffer().
Referenced by CopyFrom().
◆ simple_heap_delete()
| void simple_heap_delete | ( | Relation | relation, |
| const ItemPointerData * | tid | ||
| ) |
Definition at line 3227 of file heapam.c.
3228{
3229 TM_Result result;
3230 TM_FailureData tmfd;
3231
3232 result = heap_delete(relation, tid,
3234 true /* wait for commit */ ,
3235 &tmfd, false /* changingPart */ );
3236 switch (result)
3237 {
3239 /* Tuple was already updated in current command? */
3241 break;
3242
3244 /* done successfully */
3245 break;
3246
3249 break;
3250
3253 break;
3254
3255 default:
3257 break;
3258 }
3259}
TM_Result heap_delete(Relation relation, const ItemPointerData *tid, CommandId cid, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart)
Definition: heapam.c:2804
Definition: tableam.h:148
References elog, ERROR, GetCurrentCommandId(), heap_delete(), InvalidSnapshot, TM_Deleted, TM_Ok, TM_SelfModified, and TM_Updated.
Referenced by CatalogTupleDelete(), and toast_delete_datum().
◆ simple_heap_insert()
Definition at line 2746 of file heapam.c.
2747{
2749}
void heap_insert(Relation relation, HeapTuple tup, CommandId cid, int options, BulkInsertState bistate)
Definition: heapam.c:2103
References GetCurrentCommandId(), and heap_insert().
Referenced by CatalogTupleInsert(), CatalogTupleInsertWithInfo(), and InsertOneTuple().
◆ simple_heap_update()
| void simple_heap_update | ( | Relation | relation, |
| const ItemPointerData * | otid, | ||
| HeapTuple | tup, | ||
| TU_UpdateIndexes * | update_indexes | ||
| ) |
Definition at line 4517 of file heapam.c.
4519{
4520 TM_Result result;
4521 TM_FailureData tmfd;
4522 LockTupleMode lockmode;
4523
4524 result = heap_update(relation, otid, tup,
4526 true /* wait for commit */ ,
4527 &tmfd, &lockmode, update_indexes);
4528 switch (result)
4529 {
4531 /* Tuple was already updated in current command? */
4533 break;
4534
4536 /* done successfully */
4537 break;
4538
4541 break;
4542
4545 break;
4546
4547 default:
4549 break;
4550 }
4551}
TM_Result heap_update(Relation relation, const ItemPointerData *otid, HeapTuple newtup, CommandId cid, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)
Definition: heapam.c:3273
References elog, ERROR, GetCurrentCommandId(), heap_update(), InvalidSnapshot, TM_Deleted, TM_Ok, TM_SelfModified, and TM_Updated.
Referenced by CatalogTupleUpdate(), and CatalogTupleUpdateWithInfo().
◆ test_lockmode_for_conflict()
|
static |
Definition at line 5633 of file heapam.c.
5636{
5637 MultiXactStatus wantedstatus;
5638
5639 *needwait = false;
5641
5642 /*
5643 * Note: we *must* check TransactionIdIsInProgress before
5644 * TransactionIdDidAbort/Commit; see comment at top of heapam_visibility.c
5645 * for an explanation.
5646 */
5648 {
5649 /*
5650 * The tuple has already been locked by our own transaction. This is
5651 * very rare but can happen if multiple transactions are trying to
5652 * lock an ancient version of the same tuple.
5653 */
5655 }
5657 {
5658 /*
5659 * If the locking transaction is running, what we do depends on
5660 * whether the lock modes conflict: if they do, then we must wait for
5661 * it to finish; otherwise we can fall through to lock this tuple
5662 * version without waiting.
5663 */
5665 LOCKMODE_from_mxstatus(wantedstatus)))
5666 {
5667 *needwait = true;
5668 }
5669
5670 /*
5671 * If we set needwait above, then this value doesn't matter;
5672 * otherwise, this value signals to caller that it's okay to proceed.
5673 */
5675 }
5679 {
5680 /*
5681 * The other transaction committed. If it was only a locker, then the
5682 * lock is completely gone now and we can return success; but if it
5683 * was an update, then what we do depends on whether the two lock
5684 * modes conflict. If they conflict, then we must report error to
5685 * caller. But if they don't, we can fall through to allow the current
5686 * transaction to lock the tuple.
5687 *
5688 * Note: the reason we worry about ISUPDATE here is because as soon as
5689 * a transaction ends, all its locks are gone and meaningless, and
5690 * thus we can ignore them; whereas its updates persist. In the
5691 * TransactionIdIsInProgress case, above, we don't need to check
5692 * because we know the lock is still "alive" and thus a conflict needs
5693 * always be checked.
5694 */
5697
5699 LOCKMODE_from_mxstatus(wantedstatus)))
5700 {
5701 /* bummer */
5704 else
5706 }
5707
5709 }
5710
5711 /* Not in progress, not aborted, not committed -- must have crashed */
5713}
References DoLockModesConflict(), get_mxact_status_for_lock(), ISUPDATE_from_mxstatus, ItemPointerEquals(), LOCKMODE_from_mxstatus, mode, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_self, TM_Deleted, TM_Ok, TM_SelfModified, TM_Updated, TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdIsCurrentTransactionId(), and TransactionIdIsInProgress().
Referenced by heap_lock_updated_tuple_rec().
◆ UpdateXmaxHintBits()
|
static |
Definition at line 2014 of file heapam.c.
2015{
2018
2020 {
2022 TransactionIdDidCommit(xid))
2024 xid);
2025 else
2027 InvalidTransactionId);
2028 }
2029}
void HeapTupleSetHintBits(HeapTupleHeader tuple, Buffer buffer, uint16 infomask, TransactionId xid)
Definition: heapam_visibility.c:141
References Assert(), HEAP_XMAX_COMMITTED, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax(), HeapTupleSetHintBits(), InvalidTransactionId, HeapTupleHeaderData::t_infomask, TransactionIdDidCommit(), and TransactionIdEquals.
Referenced by heap_delete(), heap_lock_tuple(), and heap_update().
◆ xmax_infomask_changed()
Definition at line 2781 of file heapam.c.
2782{
2785
2786 if ((new_infomask & interesting) != (old_infomask & interesting))
2787 return true;
2788
2789 return false;
2790}
References HEAP_LOCK_MASK, HEAP_XMAX_IS_MULTI, and HEAP_XMAX_LOCK_ONLY.
Referenced by heap_delete(), heap_lock_tuple(), and heap_update().
Variable Documentation
◆ hwlock
◆ lockstatus
◆ MultiXactStatusLock
|
static |
Initial value:
=
{
}
◆
| const struct { ... } tupleLockExtraInfo[MaxLockTupleMode + 1] |
Initial value:
=
{
{
-1
},
{
-1
},
{
},
{
}
}
Referenced by DoesMultiXactIdConflict(), and get_mxact_status_for_lock().
