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 223 of file heapam.c.
224{
225#ifdef USE_ASSERT_CHECKING
226
227 /* bootstrap mode in particular breaks this rule */
229 return;
230
231 /* if the relation doesn't have a TOAST table, we are good */
233 return;
234
236
237#endif /* USE_ASSERT_CHECKING */
238}
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 315 of file heapam.c.
317{
318 TBMIterateResult *tbmres = per_buffer_data;
322
323 for (;;)
324 {
325 CHECK_FOR_INTERRUPTS();
326
327 /* no more entries in the bitmap */
330
331 /*
332 * Ignore any claimed entries past what we think is the end of the
333 * relation. It may have been extended after the start of our scan (we
334 * only hold an AccessShareLock, and it could be inserts from this
335 * backend). We don't take this optimization in SERIALIZABLE
336 * isolation though, as we need to examine all invisible tuples
337 * reachable by the index.
338 */
341 continue;
342
344 }
345
346 /* not reachable */
348}
Definition: heapam.h:105
Definition: heapam.h:57
Definition: tidbitmap.h:62
Definition: relscan.h:34
union TableScanDescData::@49 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 8604 of file heapam.c.
8606{
8607 int64 lastblock = -1;
8608 int nblocksfavorable = 0;
8609
8610 Assert(nblockgroups >= 1);
8612
8613 /*
8614 * We tolerate heap blocks that will be accessed only slightly out of
8615 * physical order. Small blips occur when a pair of almost-contiguous
8616 * blocks happen to fall into different buckets (perhaps due only to a
8617 * small difference in npromisingtids that the bucketing scheme didn't
8618 * quite manage to ignore). We effectively ignore these blips by applying
8619 * a small tolerance. The precise tolerance we use is a little arbitrary,
8620 * but it works well enough in practice.
8621 */
8623 {
8627
8628 if (lastblock != -1 &&
8631 break;
8632
8633 nblocksfavorable++;
8634 lastblock = block;
8635 }
8636
8637 /* Always indicate that there is at least 1 favorable block */
8638 Assert(nblocksfavorable >= 1);
8639
8640 return nblocksfavorable;
8641}
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
Definition: heapam.c:195
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 8720 of file heapam.c.
8721{
8722 IndexDeleteCounts *blockgroups;
8723 TM_IndexDelete *reordereddeltids;
8725 int nblockgroups = 0;
8726 int ncopied = 0;
8727 int nblocksfavorable = 0;
8728
8731
8732 /* Calculate per-heap-block count of TIDs */
8735 {
8740
8742 {
8743 /* New block group */
8744 nblockgroups++;
8745
8747 !BlockNumberIsValid(curblock));
8748
8749 curblock = ItemPointerGetBlockNumber(htid);
8751 blockgroups[nblockgroups - 1].ntids = 1;
8752 blockgroups[nblockgroups - 1].npromisingtids = 0;
8753 }
8754 else
8755 {
8756 blockgroups[nblockgroups - 1].ntids++;
8757 }
8758
8759 if (promising)
8760 blockgroups[nblockgroups - 1].npromisingtids++;
8761 }
8762
8763 /*
8764 * We're about ready to sort block groups to determine the optimal order
8765 * for visiting heap blocks. But before we do, round the number of
8766 * promising tuples for each block group up to the next power-of-two,
8767 * unless it is very low (less than 4), in which case we round up to 4.
8768 * npromisingtids is far too noisy to trust when choosing between a pair
8769 * of block groups that both have very low values.
8770 *
8771 * This scheme divides heap blocks/block groups into buckets. Each bucket
8772 * contains blocks that have _approximately_ the same number of promising
8773 * TIDs as each other. The goal is to ignore relatively small differences
8774 * in the total number of promising entries, so that the whole process can
8775 * give a little weight to heapam factors (like heap block locality)
8776 * instead. This isn't a trade-off, really -- we have nothing to lose. It
8777 * would be foolish to interpret small differences in npromisingtids
8778 * values as anything more than noise.
8779 *
8780 * We tiebreak on nhtids when sorting block group subsets that have the
8781 * same npromisingtids, but this has the same issues as npromisingtids,
8782 * and so nhtids is subject to the same power-of-two bucketing scheme. The
8783 * only reason that we don't fix nhtids in the same way here too is that
8784 * we'll need accurate nhtids values after the sort. We handle nhtids
8785 * bucketization dynamically instead (in the sort comparator).
8786 *
8787 * See bottomup_nblocksfavorable() for a full explanation of when and how
8788 * heap locality/favorable blocks can significantly influence when and how
8789 * heap blocks are accessed.
8790 */
8792 {
8794
8795 /* Better off falling back on nhtids with low npromisingtids */
8797 group->npromisingtids = 4;
8798 else
8799 group->npromisingtids =
8801 }
8802
8803 /* Sort groups and rearrange caller's deltids array */
8805 bottomup_sort_and_shrink_cmp);
8807
8809 /* Determine number of favorable blocks at the start of final deltids */
8810 nblocksfavorable = bottomup_nblocksfavorable(blockgroups, nblockgroups,
8811 delstate->deltids);
8812
8814 {
8817
8818 memcpy(reordereddeltids + ncopied, firstdtid,
8820 ncopied += group->ntids;
8821 }
8822
8823 /* Copy final grouped and sorted TIDs back into start of caller's array */
8824 memcpy(delstate->deltids, reordereddeltids,
8826 delstate->ndeltids = ncopied;
8827
8828 pfree(reordereddeltids);
8829 pfree(blockgroups);
8830
8831 return nblocksfavorable;
8832}
static int bottomup_nblocksfavorable(IndexDeleteCounts *blockgroups, int nblockgroups, TM_IndexDelete *deltids)
Definition: heapam.c:8604
static int bottomup_sort_and_shrink_cmp(const void *arg1, const void *arg2)
Definition: heapam.c:8647
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(), palloc_array, 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 8647 of file heapam.c.
8648{
8651
8652 /*
8653 * Most significant field is npromisingtids (which we invert the order of
8654 * so as to sort in desc order).
8655 *
8656 * Caller should have already normalized npromisingtids fields into
8657 * power-of-two values (buckets).
8658 */
8660 return -1;
8662 return 1;
8663
8664 /*
8665 * Tiebreak: desc ntids sort order.
8666 *
8667 * We cannot expect power-of-two values for ntids fields. We should
8668 * behave as if they were already rounded up for us instead.
8669 */
8671 {
8674
8675 if (ntids1 > ntids2)
8676 return -1;
8677 if (ntids1 < ntids2)
8678 return 1;
8679 }
8680
8681 /*
8682 * Tiebreak: asc offset-into-deltids-for-block (offset to first TID for
8683 * block in deltids array) order.
8684 *
8685 * This is equivalent to sorting in ascending heap block number order
8686 * (among otherwise equal subsets of the array). This approach allows us
8687 * to avoid accessing the out-of-line TID. (We rely on the assumption
8688 * that the deltids array was sorted in ascending heap TID order when
8689 * these offsets to the first TID from each heap block group were formed.)
8690 */
8692 return 1;
8694 return -1;
8695
8696 pg_unreachable();
8697
8698 return 0;
8699}
References IndexDeleteCounts::ifirsttid, IndexDeleteCounts::npromisingtids, IndexDeleteCounts::ntids, pg_nextpower2_32(), and pg_unreachable.
Referenced by bottomup_sort_and_shrink().
◆ compute_infobits()
Definition at line 2762 of file heapam.c.
2763{
2764 return
2768 /* note we ignore HEAP_XMAX_SHR_LOCK here */
2770 ((infomask2 & HEAP_KEYS_UPDATED) != 0 ?
2771 XLHL_KEYS_UPDATED : 0);
2772}
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 5359 of file heapam.c.
5364{
5365 TransactionId new_xmax;
5366 uint16 new_infomask,
5367 new_infomask2;
5368
5370
5371l5:
5372 new_infomask = 0;
5373 new_infomask2 = 0;
5375 {
5376 /*
5377 * No previous locker; we just insert our own TransactionId.
5378 *
5379 * Note that it's critical that this case be the first one checked,
5380 * because there are several blocks below that come back to this one
5381 * to implement certain optimizations; old_infomask might contain
5382 * other dirty bits in those cases, but we don't really care.
5383 */
5384 if (is_update)
5385 {
5386 new_xmax = add_to_xmax;
5388 new_infomask2 |= HEAP_KEYS_UPDATED;
5389 }
5390 else
5391 {
5392 new_infomask |= HEAP_XMAX_LOCK_ONLY;
5394 {
5396 new_xmax = add_to_xmax;
5397 new_infomask |= HEAP_XMAX_KEYSHR_LOCK;
5398 break;
5400 new_xmax = add_to_xmax;
5401 new_infomask |= HEAP_XMAX_SHR_LOCK;
5402 break;
5404 new_xmax = add_to_xmax;
5405 new_infomask |= HEAP_XMAX_EXCL_LOCK;
5406 break;
5408 new_xmax = add_to_xmax;
5409 new_infomask |= HEAP_XMAX_EXCL_LOCK;
5410 new_infomask2 |= HEAP_KEYS_UPDATED;
5411 break;
5412 default:
5415 }
5416 }
5417 }
5419 {
5420 MultiXactStatus new_status;
5421
5422 /*
5423 * Currently we don't allow XMAX_COMMITTED to be set for multis, so
5424 * cross-check.
5425 */
5427
5428 /*
5429 * A multixact together with LOCK_ONLY set but neither lock bit set
5430 * (i.e. a pg_upgraded share locked tuple) cannot possibly be running
5431 * anymore. This check is critical for databases upgraded by
5432 * pg_upgrade; both MultiXactIdIsRunning and MultiXactIdExpand assume
5433 * that such multis are never passed.
5434 */
5436 {
5437 old_infomask &= ~HEAP_XMAX_IS_MULTI;
5438 old_infomask |= HEAP_XMAX_INVALID;
5439 goto l5;
5440 }
5441
5442 /*
5443 * If the XMAX is already a MultiXactId, then we need to expand it to
5444 * include add_to_xmax; but if all the members were lockers and are
5445 * all gone, we can do away with the IS_MULTI bit and just set
5446 * add_to_xmax as the only locker/updater. If all lockers are gone
5447 * and we have an updater that aborted, we can also do without a
5448 * multi.
5449 *
5450 * The cost of doing GetMultiXactIdMembers would be paid by
5451 * MultiXactIdExpand if we weren't to do this, so this check is not
5452 * incurring extra work anyhow.
5453 */
5455 {
5458 old_infomask)))
5459 {
5460 /*
5461 * Reset these bits and restart; otherwise fall through to
5462 * create a new multi below.
5463 */
5464 old_infomask &= ~HEAP_XMAX_IS_MULTI;
5465 old_infomask |= HEAP_XMAX_INVALID;
5466 goto l5;
5467 }
5468 }
5469
5471
5473 new_status);
5474 GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5475 }
5477 {
5478 /*
5479 * It's a committed update, so we need to preserve him as updater of
5480 * the tuple.
5481 */
5482 MultiXactStatus status;
5483 MultiXactStatus new_status;
5484
5486 status = MultiXactStatusUpdate;
5487 else
5488 status = MultiXactStatusNoKeyUpdate;
5489
5491
5492 /*
5493 * since it's not running, it's obviously impossible for the old
5494 * updater to be identical to the current one, so we need not check
5495 * for that case as we do in the block above.
5496 */
5497 new_xmax = MultiXactIdCreate(xmax, status, add_to_xmax, new_status);
5498 GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5499 }
5501 {
5502 /*
5503 * If the XMAX is a valid, in-progress TransactionId, then we need to
5504 * create a new MultiXactId that includes both the old locker or
5505 * updater and our own TransactionId.
5506 */
5507 MultiXactStatus new_status;
5508 MultiXactStatus old_status;
5509 LockTupleMode old_mode;
5510
5512 {
5514 old_status = MultiXactStatusForKeyShare;
5516 old_status = MultiXactStatusForShare;
5518 {
5520 old_status = MultiXactStatusForUpdate;
5521 else
5522 old_status = MultiXactStatusForNoKeyUpdate;
5523 }
5524 else
5525 {
5526 /*
5527 * LOCK_ONLY can be present alone only when a page has been
5528 * upgraded by pg_upgrade. But in that case,
5529 * TransactionIdIsInProgress() should have returned false. We
5530 * assume it's no longer locked in this case.
5531 */
5533 old_infomask |= HEAP_XMAX_INVALID;
5534 old_infomask &= ~HEAP_XMAX_LOCK_ONLY;
5535 goto l5;
5536 }
5537 }
5538 else
5539 {
5540 /* it's an update, but which kind? */
5542 old_status = MultiXactStatusUpdate;
5543 else
5544 old_status = MultiXactStatusNoKeyUpdate;
5545 }
5546
5547 old_mode = TUPLOCK_from_mxstatus(old_status);
5548
5549 /*
5550 * If the lock to be acquired is for the same TransactionId as the
5551 * existing lock, there's an optimization possible: consider only the
5552 * strongest of both locks as the only one present, and restart.
5553 */
5554 if (xmax == add_to_xmax)
5555 {
5556 /*
5557 * Note that it's not possible for the original tuple to be
5558 * updated: we wouldn't be here because the tuple would have been
5559 * invisible and we wouldn't try to update it. As a subtlety,
5560 * this code can also run when traversing an update chain to lock
5561 * future versions of a tuple. But we wouldn't be here either,
5562 * because the add_to_xmax would be different from the original
5563 * updater.
5564 */
5566
5567 /* acquire the strongest of both */
5569 mode = old_mode;
5570 /* mustn't touch is_update */
5571
5572 old_infomask |= HEAP_XMAX_INVALID;
5573 goto l5;
5574 }
5575
5576 /* otherwise, just fall back to creating a new multixact */
5578 new_xmax = MultiXactIdCreate(xmax, old_status,
5579 add_to_xmax, new_status);
5580 GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5581 }
5583 TransactionIdDidCommit(xmax))
5584 {
5585 /*
5586 * It's a committed update, so we gotta preserve him as updater of the
5587 * tuple.
5588 */
5589 MultiXactStatus status;
5590 MultiXactStatus new_status;
5591
5593 status = MultiXactStatusUpdate;
5594 else
5595 status = MultiXactStatusNoKeyUpdate;
5596
5598
5599 /*
5600 * since it's not running, it's obviously impossible for the old
5601 * updater to be identical to the current one, so we need not check
5602 * for that case as we do in the block above.
5603 */
5604 new_xmax = MultiXactIdCreate(xmax, status, add_to_xmax, new_status);
5605 GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5606 }
5607 else
5608 {
5609 /*
5610 * Can get here iff the locking/updating transaction was running when
5611 * the infomask was extracted from the tuple, but finished before
5612 * TransactionIdIsInProgress got to run. Deal with it as if there was
5613 * no locker at all in the first place.
5614 */
5615 old_infomask |= HEAP_XMAX_INVALID;
5616 goto l5;
5617 }
5618
5619 *result_infomask = new_infomask;
5620 *result_infomask2 = new_infomask2;
5621 *result_xmax = new_xmax;
5622}
static void GetMultiXactIdHintBits(MultiXactId multi, uint16 *new_infomask, uint16 *new_infomask2)
Definition: heapam.c:7491
static TransactionId MultiXactIdGetUpdateXid(TransactionId xmax, uint16 t_infomask)
Definition: heapam.c:7572
static MultiXactStatus get_mxact_status_for_lock(LockTupleMode mode, bool is_update)
Definition: heapam.c:4561
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:354
bool MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly)
Definition: multixact.c:465
MultiXactId MultiXactIdCreate(TransactionId xid1, MultiXactStatus status1, TransactionId xid2, MultiXactStatus status2)
Definition: multixact.c:301
bool TransactionIdIsInProgress(TransactionId xid)
Definition: procarray.c:1404
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 7840 of file heapam.c.
7843{
7846}
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:7740
References Do_MultiXactIdWait(), remaining, and XLTW_None.
Referenced by heap_lock_tuple().
◆ Do_MultiXactIdWait()
|
static |
Definition at line 7740 of file heapam.c.
7744{
7745 bool result = true;
7746 MultiXactMember *members;
7747 int nmembers;
7748 int remain = 0;
7749
7750 /* for pre-pg_upgrade tuples, no need to sleep at all */
7751 nmembers = HEAP_LOCKED_UPGRADED(infomask) ? -1 :
7753 HEAP_XMAX_IS_LOCKED_ONLY(infomask));
7754
7755 if (nmembers >= 0)
7756 {
7758
7760 {
7763
7765 {
7766 remain++;
7767 continue;
7768 }
7769
7771 LOCKMODE_from_mxstatus(status)))
7772 {
7774 remain++;
7775 continue;
7776 }
7777
7778 /*
7779 * This member conflicts with our multi, so we have to sleep (or
7780 * return failure, if asked to avoid waiting.)
7781 *
7782 * Note that we don't set up an error context callback ourselves,
7783 * but instead we pass the info down to XactLockTableWait. This
7784 * might seem a bit wasteful because the context is set up and
7785 * tore down for each member of the multixact, but in reality it
7786 * should be barely noticeable, and it avoids duplicate code.
7787 */
7788 if (nowait)
7789 {
7790 result = ConditionalXactLockTableWait(memxid, logLockFailure);
7791 if (!result)
7792 break;
7793 }
7794 else
7796 }
7797
7798 pfree(members);
7799 }
7800
7802 *remaining = remain;
7803
7804 return result;
7805}
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:1115
Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
Definition: parse_oper.c:371
Definition: multixact.h:56
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 7640 of file heapam.c.
7642{
7643 int nmembers;
7644 MultiXactMember *members;
7645 bool result = false;
7647
7649 return false;
7650
7652 HEAP_XMAX_IS_LOCKED_ONLY(infomask));
7653 if (nmembers >= 0)
7654 {
7656
7658 {
7659 TransactionId memxid;
7660 LOCKMODE memlockmode;
7661
7662 if (result && (current_is_member == NULL || *current_is_member))
7663 break;
7664
7666
7667 /* ignore members from current xact (but track their presence) */
7670 {
7671 if (current_is_member != NULL)
7672 *current_is_member = true;
7673 continue;
7674 }
7675 else if (result)
7676 continue;
7677
7678 /* ignore members that don't conflict with the lock we want */
7680 continue;
7681
7683 {
7684 /* ignore aborted updaters */
7686 continue;
7687 }
7688 else
7689 {
7690 /* ignore lockers-only that are no longer in progress */
7692 continue;
7693 }
7694
7695 /*
7696 * Whatever remains are either live lockers that conflict with our
7697 * wanted lock, and updaters that are not aborted. Those conflict
7698 * with what we want. Set up to return true, but keep going to
7699 * look for the current transaction among the multixact members,
7700 * if needed.
7701 */
7702 result = true;
7703 }
7704 pfree(members);
7705 }
7706
7707 return result;
7708}
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 9186 of file heapam.c.
9188{
9191 Bitmapset *idattrs;
9192 HeapTuple key_tuple;
9195
9196 *copy = false;
9197
9199 return NULL;
9200
9201 if (replident == REPLICA_IDENTITY_NOTHING)
9202 return NULL;
9203
9204 if (replident == REPLICA_IDENTITY_FULL)
9205 {
9206 /*
9207 * When logging the entire old tuple, it very well could contain
9208 * toasted columns. If so, force them to be inlined.
9209 */
9211 {
9212 *copy = true;
9213 tp = toast_flatten_tuple(tp, desc);
9214 }
9215 return tp;
9216 }
9217
9218 /* if the key isn't required and we're only logging the key, we're done */
9219 if (!key_required)
9220 return NULL;
9221
9222 /* find out the replica identity columns */
9223 idattrs = RelationGetIndexAttrBitmap(relation,
9225
9226 /*
9227 * If there's no defined replica identity columns, treat as !key_required.
9228 * (This case should not be reachable from heap_update, since that should
9229 * calculate key_required accurately. But heap_delete just passes
9230 * constant true for key_required, so we can hit this case in deletes.)
9231 */
9233 return NULL;
9234
9235 /*
9236 * Construct a new tuple containing only the replica identity columns,
9237 * with nulls elsewhere. While we're at it, assert that the replica
9238 * identity columns aren't null.
9239 */
9241
9243 {
9245 idattrs))
9247 else
9249 }
9250
9252 *copy = true;
9253
9254 bms_free(idattrs);
9255
9256 /*
9257 * If the tuple, which by here only contains indexed columns, still has
9258 * toasted columns, force them to be inlined. This is somewhat unlikely
9259 * since there's limits on the size of indexed columns, so we don't
9260 * duplicate toast_flatten_tuple()s functionality in the above loop over
9261 * the indexed columns, even if it would be more efficient.
9262 */
9264 {
9265 HeapTuple oldtup = key_tuple;
9266
9267 key_tuple = toast_flatten_tuple(oldtup, desc);
9268 heap_freetuple(oldtup);
9269 }
9270
9271 return key_tuple;
9272}
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:5298
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 2056 of file heapam.c.
References BulkInsertStateData::current_buf, FreeAccessStrategy(), InvalidBuffer, pfree(), ReleaseBuffer(), and BulkInsertStateData::strategy.
Referenced by ATRewriteTable(), CopyFrom(), CopyMultiInsertBufferCleanup(), deleteSplitPartitionContext(), intorel_shutdown(), MergePartitionsMoveRows(), and transientrel_shutdown().
◆ FreezeMultiXactId()
|
static |
Definition at line 6749 of file heapam.c.
6752{
6753 TransactionId newxmax;
6754 MultiXactMember *members;
6755 int nmembers;
6756 bool need_replace;
6757 int nnewmembers;
6758 MultiXactMember *newmembers;
6759 bool has_lockers;
6760 TransactionId update_xid;
6761 bool update_committed;
6762 TransactionId FreezePageRelfrozenXid;
6763
6764 *flags = 0;
6765
6766 /* We should only be called in Multis */
6768
6770 HEAP_LOCKED_UPGRADED(t_infomask))
6771 {
6772 *flags |= FRM_INVALIDATE_XMAX;
6775 }
6780 multi, cutoffs->relminmxid)));
6782 {
6783 TransactionId update_xact;
6784
6785 /*
6786 * This old multi cannot possibly have members still running, but
6787 * verify just in case. If it was a locker only, it can be removed
6788 * without any further consideration; but if it contained an update,
6789 * we might need to preserve it.
6790 */
6792 HEAP_XMAX_IS_LOCKED_ONLY(t_infomask)))
6796 multi, cutoffs->OldestMxact)));
6797
6799 {
6800 *flags |= FRM_INVALIDATE_XMAX;
6803 }
6804
6805 /* replace multi with single XID for its updater? */
6806 update_xact = MultiXactIdGetUpdateXid(multi, t_infomask);
6811 multi, update_xact,
6812 cutoffs->relfrozenxid)));
6814 {
6815 /*
6816 * Updater XID has to have aborted (otherwise the tuple would have
6817 * been pruned away instead, since updater XID is < OldestXmin).
6818 * Just remove xmax.
6819 */
6823 errmsg_internal("multixact %u contains committed update XID %u from before removable cutoff %u",
6824 multi, update_xact,
6825 cutoffs->OldestXmin)));
6826 *flags |= FRM_INVALIDATE_XMAX;
6829 }
6830
6831 /* Have to keep updater XID as new xmax */
6832 *flags |= FRM_RETURN_IS_XID;
6834 return update_xact;
6835 }
6836
6837 /*
6838 * Some member(s) of this Multi may be below FreezeLimit xid cutoff, so we
6839 * need to walk the whole members array to figure out what to do, if
6840 * anything.
6841 */
6842 nmembers =
6844 HEAP_XMAX_IS_LOCKED_ONLY(t_infomask));
6845 if (nmembers <= 0)
6846 {
6847 /* Nothing worth keeping */
6848 *flags |= FRM_INVALIDATE_XMAX;
6851 }
6852
6853 /*
6854 * The FRM_NOOP case is the only case where we might need to ratchet back
6855 * FreezePageRelfrozenXid or FreezePageRelminMxid. It is also the only
6856 * case where our caller might ratchet back its NoFreezePageRelfrozenXid
6857 * or NoFreezePageRelminMxid "no freeze" trackers to deal with a multi.
6858 * FRM_NOOP handling should result in the NewRelfrozenXid/NewRelminMxid
6859 * trackers managed by VACUUM being ratcheting back by xmax to the degree
6860 * required to make it safe to leave xmax undisturbed, independent of
6861 * whether or not page freezing is triggered somewhere else.
6862 *
6863 * Our policy is to force freezing in every case other than FRM_NOOP,
6864 * which obviates the need to maintain either set of trackers, anywhere.
6865 * Every other case will reliably execute a freeze plan for xmax that
6866 * either replaces xmax with an XID/MXID >= OldestXmin/OldestMxact, or
6867 * sets xmax to an InvalidTransactionId XID, rendering xmax fully frozen.
6868 * (VACUUM's NewRelfrozenXid/NewRelminMxid trackers are initialized with
6869 * OldestXmin/OldestMxact, so later values never need to be tracked here.)
6870 */
6871 need_replace = false;
6872 FreezePageRelfrozenXid = pagefrz->FreezePageRelfrozenXid;
6874 {
6876
6878
6880 {
6881 /* Can't violate the FreezeLimit postcondition */
6882 need_replace = true;
6883 break;
6884 }
6886 FreezePageRelfrozenXid = xid;
6887 }
6888
6889 /* Can't violate the MultiXactCutoff postcondition, either */
6890 if (!need_replace)
6892
6893 if (!need_replace)
6894 {
6895 /*
6896 * vacuumlazy.c might ratchet back NewRelminMxid, NewRelfrozenXid, or
6897 * both together to make it safe to retain this particular multi after
6898 * freezing its page
6899 */
6900 *flags |= FRM_NOOP;
6901 pagefrz->FreezePageRelfrozenXid = FreezePageRelfrozenXid;
6903 pagefrz->FreezePageRelminMxid = multi;
6904 pfree(members);
6905 return multi;
6906 }
6907
6908 /*
6909 * Do a more thorough second pass over the multi to figure out which
6910 * member XIDs actually need to be kept. Checking the precise status of
6911 * individual members might even show that we don't need to keep anything.
6912 * That is quite possible even though the Multi must be >= OldestMxact,
6913 * since our second pass only keeps member XIDs when it's truly necessary;
6914 * even member XIDs >= OldestXmin often won't be kept by second pass.
6915 */
6916 nnewmembers = 0;
6918 has_lockers = false;
6919 update_xid = InvalidTransactionId;
6920 update_committed = false;
6921
6922 /*
6923 * Determine whether to keep each member xid, or to ignore it instead
6924 */
6926 {
6929
6931
6933 {
6934 /*
6935 * Locker XID (not updater XID). We only keep lockers that are
6936 * still running.
6937 */
6939 TransactionIdIsInProgress(xid))
6940 {
6945 multi, xid,
6946 cutoffs->OldestXmin)));
6947 newmembers[nnewmembers++] = members[i];
6948 has_lockers = true;
6949 }
6950
6951 continue;
6952 }
6953
6954 /*
6955 * Updater XID (not locker XID). Should we keep it?
6956 *
6957 * Since the tuple wasn't totally removed when vacuum pruned, the
6958 * update Xid cannot possibly be older than OldestXmin cutoff unless
6959 * the updater XID aborted. If the updater transaction is known
6960 * aborted or crashed then it's okay to ignore it, otherwise not.
6961 *
6962 * In any case the Multi should never contain two updaters, whatever
6963 * their individual commit status. Check for that first, in passing.
6964 */
6969 multi),
6971 update_xid, xid)));
6972
6973 /*
6974 * As with all tuple visibility routines, it's critical to test
6975 * TransactionIdIsInProgress before TransactionIdDidCommit, because of
6976 * race conditions explained in detail in heapam_visibility.c.
6977 */
6979 TransactionIdIsInProgress(xid))
6980 update_xid = xid;
6982 {
6983 /*
6984 * The transaction committed, so we can tell caller to set
6985 * HEAP_XMAX_COMMITTED. (We can only do this because we know the
6986 * transaction is not running.)
6987 */
6988 update_committed = true;
6989 update_xid = xid;
6990 }
6991 else
6992 {
6993 /*
6994 * Not in progress, not committed -- must be aborted or crashed;
6995 * we can ignore it.
6996 */
6997 continue;
6998 }
6999
7000 /*
7001 * We determined that updater must be kept -- add it to pending new
7002 * members list
7003 */
7007 errmsg_internal("multixact %u contains committed update XID %u from before removable cutoff %u",
7008 multi, xid, cutoffs->OldestXmin)));
7009 newmembers[nnewmembers++] = members[i];
7010 }
7011
7012 pfree(members);
7013
7014 /*
7015 * Determine what to do with caller's multi based on information gathered
7016 * during our second pass
7017 */
7018 if (nnewmembers == 0)
7019 {
7020 /* Nothing worth keeping */
7021 *flags |= FRM_INVALIDATE_XMAX;
7022 newxmax = InvalidTransactionId;
7023 }
7025 {
7026 /*
7027 * If there's a single member and it's an update, pass it back alone
7028 * without creating a new Multi. (XXX we could do this when there's a
7029 * single remaining locker, too, but that would complicate the API too
7030 * much; moreover, the case with the single updater is more
7031 * interesting, because those are longer-lived.)
7032 */
7033 Assert(nnewmembers == 1);
7034 *flags |= FRM_RETURN_IS_XID;
7035 if (update_committed)
7036 *flags |= FRM_MARK_COMMITTED;
7037 newxmax = update_xid;
7038 }
7039 else
7040 {
7041 /*
7042 * Create a new multixact with the surviving members of the previous
7043 * one, to set as new Xmax in the tuple
7044 */
7045 newxmax = MultiXactIdCreateFromMembers(nnewmembers, newmembers);
7046 *flags |= FRM_RETURN_IS_MULTI;
7047 }
7048
7049 pfree(newmembers);
7050
7052 return newxmax;
7053}
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:2833
MultiXactId MultiXactIdCreateFromMembers(int nmembers, MultiXactMember *members)
Definition: multixact.c:658
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_array, 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 4561 of file heapam.c.
4562{
4563 int retval;
4564
4565 if (is_update)
4567 else
4569
4570 if (retval == -1)
4572 is_update ? "true" : "false");
4573
4575}
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 2039 of file heapam.c.
2040{
2041 BulkInsertState bistate;
2042
2048 bistate->already_extended_by = 0;
2049 return bistate;
2050}
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_object, and BulkInsertStateData::strategy.
Referenced by ATRewriteTable(), CopyFrom(), CopyMultiInsertBufferInit(), createSplitPartitionContext(), intorel_startup(), MergePartitionsMoveRows(), and transientrel_startup().
◆ GetMultiXactIdHintBits()
|
static |
Definition at line 7491 of file heapam.c.
7493{
7494 int nmembers;
7495 MultiXactMember *members;
7498 uint16 bits2 = 0;
7499 bool has_update = false;
7501
7502 /*
7503 * We only use this in multis we just created, so they cannot be values
7504 * pre-pg_upgrade.
7505 */
7507
7509 {
7511
7512 /*
7513 * Remember the strongest lock mode held by any member of the
7514 * multixact.
7515 */
7518 strongest = mode;
7519
7520 /* See what other bits we need */
7522 {
7526 break;
7527
7529 bits2 |= HEAP_KEYS_UPDATED;
7530 break;
7531
7533 has_update = true;
7534 break;
7535
7537 bits2 |= HEAP_KEYS_UPDATED;
7538 has_update = true;
7539 break;
7540 }
7541 }
7542
7544 strongest == LockTupleNoKeyExclusive)
7545 bits |= HEAP_XMAX_EXCL_LOCK;
7547 bits |= HEAP_XMAX_SHR_LOCK;
7549 bits |= HEAP_XMAX_KEYSHR_LOCK;
7550
7551 if (!has_update)
7552 bits |= HEAP_XMAX_LOCK_ONLY;
7553
7554 if (nmembers > 0)
7555 pfree(members);
7556
7557 *new_infomask = bits;
7558 *new_infomask2 = bits2;
7559}
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 6219 of file heapam.c.
6220{
6222 ItemId lp;
6223 HeapTupleData tp;
6224 Page page;
6225 BlockNumber block;
6226 Buffer buffer;
6227
6229
6230 block = ItemPointerGetBlockNumber(tid);
6231 buffer = ReadBuffer(relation, block);
6232 page = BufferGetPage(buffer);
6233
6235
6236 /*
6237 * Page can't be all visible, we just inserted into it, and are still
6238 * running.
6239 */
6241
6244
6248 tp.t_self = *tid;
6249
6250 /*
6251 * Sanity check that the tuple really is a speculatively inserted tuple,
6252 * inserted by us.
6253 */
6259
6260 /*
6261 * No need to check for serializable conflicts here. There is never a
6262 * need for a combo CID, either. No need to extract replica identity, or
6263 * do anything special with infomask bits.
6264 */
6265
6266 START_CRIT_SECTION();
6267
6268 /*
6269 * The tuple will become DEAD immediately. Flag that this page is a
6270 * candidate for pruning by setting xmin to TransactionXmin. While not
6271 * immediately prunable, it is the oldest xid we can cheaply determine
6272 * that's safe against wraparound / being older than the table's
6273 * relfrozenxid. To defend against the unlikely case of a new relation
6274 * having a newer relfrozenxid than our TransactionXmin, use relfrozenxid
6275 * if so (vacuum can't subsequently move relfrozenxid to beyond
6276 * TransactionXmin, so there's no race here).
6277 */
6279 {
6281 TransactionId prune_xid;
6282
6284 prune_xid = relfrozenxid;
6285 else
6286 prune_xid = TransactionXmin;
6287 PageSetPrunable(page, prune_xid);
6288 }
6289
6290 /* store transaction information of xact deleting the tuple */
6293
6294 /*
6295 * Set the tuple header xmin to InvalidTransactionId. This makes the
6296 * tuple immediately invisible everyone. (In particular, to any
6297 * transactions waiting on the speculative token, woken up later.)
6298 */
6300
6301 /* Clear the speculative insertion token too */
6303
6304 MarkBufferDirty(buffer);
6305
6306 /*
6307 * XLOG stuff
6308 *
6309 * The WAL records generated here match heap_delete(). The same recovery
6310 * routines are used.
6311 */
6313 {
6314 xl_heap_delete xlrec;
6315 XLogRecPtr recptr;
6316
6321 xlrec.xmax = xid;
6322
6323 XLogBeginInsert();
6326
6327 /* No replica identity & replication origin logged */
6328
6330
6331 PageSetLSN(page, recptr);
6332 }
6333
6334 END_CRIT_SECTION();
6335
6337
6339 {
6342 }
6343
6344 /*
6345 * Never need to mark tuple for invalidation, since catalogs don't support
6346 * speculative insertion
6347 */
6348
6349 /* Now we can release the buffer */
6350 ReleaseBuffer(buffer);
6351
6352 /* count deletion, as we counted the insertion too */
6353 pgstat_count_heap_delete(relation);
6354}
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:243
static void * PageGetItem(PageData *page, const ItemIdData *itemId)
Definition: bufpage.h:353
static uint8 compute_infobits(uint16 infomask, uint16 infomask2)
Definition: heapam.c:2762
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:414
union HeapTupleHeaderData::@56 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 5310 of file heapam.c.
5312{
5313 if (*have_tuple_lock)
5314 return true;
5315
5316 switch (wait_policy)
5317 {
5320 break;
5321
5324 return false;
5325 break;
5326
5330 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
5332 RelationGetRelationName(relation))));
5333 break;
5334 }
5335 *have_tuple_lock = true;
5336
5337 return true;
5338}
#define ConditionalLockTupleTuplock(rel, tup, mode, log)
Definition: heapam.c:169
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 4379 of file heapam.c.
4381{
4382 /*
4383 * If one value is NULL and other is not, then they are certainly not
4384 * equal
4385 */
4386 if (isnull1 != isnull2)
4387 return false;
4388
4389 /*
4390 * If both are NULL, they can be considered equal.
4391 */
4392 if (isnull1)
4393 return true;
4394
4395 /*
4396 * We do simple binary comparison of the two datums. This may be overly
4397 * strict because there can be multiple binary representations for the
4398 * same logical value. But we should be OK as long as there are no false
4399 * positives. Using a type-specific equality operator is messy because
4400 * there could be multiple notions of equality in different operator
4401 * classes; furthermore, we cannot safely invoke user-defined functions
4402 * while holding exclusive buffer lock.
4403 */
4404 if (attrnum <= 0)
4405 {
4406 /* The only allowed system columns are OIDs, so do this */
4408 }
4409 else
4410 {
4411 CompactAttribute *att;
4412
4413 Assert(attrnum <= tupdesc->natts);
4414 att = TupleDescCompactAttr(tupdesc, attrnum - 1);
4416 }
4417}
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 1118 of file heapam.c.
1122{
1123 HeapScanDesc scan;
1124
1125 /*
1126 * increment relation ref count while scanning relation
1127 *
1128 * This is just to make really sure the relcache entry won't go away while
1129 * the scan has a pointer to it. Caller should be holding the rel open
1130 * anyway, so this is redundant in all normal scenarios...
1131 */
1132 RelationIncrementReferenceCount(relation);
1133
1134 /*
1135 * allocate and initialize scan descriptor
1136 */
1138 {
1140
1141 /*
1142 * Bitmap Heap scans do not have any fields that a normal Heap Scan
1143 * does not have, so no special initializations required here.
1144 */
1145 scan = (HeapScanDesc) bscan;
1146 }
1147 else
1149
1157
1158 /*
1159 * Disable page-at-a-time mode if it's not a MVCC-safe snapshot.
1160 */
1163
1164 /* Check that a historic snapshot is not used for non-catalog tables */
1165 if (snapshot &&
1166 IsHistoricMVCCSnapshot(snapshot) &&
1167 !RelationIsAccessibleInLogicalDecoding(relation))
1168 {
1170 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
1172 RelationGetRelationName(relation))));
1173 }
1174
1175 /*
1176 * For seqscan and sample scans in a serializable transaction, acquire a
1177 * predicate lock on the entire relation. This is required not only to
1178 * lock all the matching tuples, but also to conflict with new insertions
1179 * into the table. In an indexscan, we take page locks on the index pages
1180 * covering the range specified in the scan qual, but in a heap scan there
1181 * is nothing more fine-grained to lock. A bitmap scan is a different
1182 * story, there we have already scanned the index and locked the index
1183 * pages covering the predicate. But in that case we still have to lock
1184 * any matching heap tuples. For sample scan we could optimize the locking
1185 * to be at least page-level granularity, but we'd need to add per-tuple
1186 * locking for that.
1187 */
1189 {
1190 /*
1191 * Ensure a missing snapshot is noticed reliably, even if the
1192 * isolation mode means predicate locking isn't performed (and
1193 * therefore the snapshot isn't used here).
1194 */
1195 Assert(snapshot);
1196 PredicateLockRelation(relation, snapshot);
1197 }
1198
1199 /* we only need to set this up once */
1201
1202 /*
1203 * Allocate memory to keep track of page allocation for parallel workers
1204 * when doing a parallel scan.
1205 */
1206 if (parallel_scan != NULL)
1208 else
1209 scan->rs_parallelworkerdata = NULL;
1210
1211 /*
1212 * we do this here instead of in initscan() because heap_rescan also calls
1213 * initscan() and we don't want to allocate memory again
1214 */
1215 if (nkeys > 0)
1217 else
1219
1221
1222 scan->rs_read_stream = NULL;
1223
1224 /*
1225 * Set up a read stream for sequential scans and TID range scans. This
1226 * should be done after initscan() because initscan() allocates the
1227 * BufferAccessStrategy object passed to the read stream API.
1228 */
1231 {
1232 ReadStreamBlockNumberCB cb;
1233
1235 cb = heap_scan_stream_read_next_parallel;
1236 else
1237 cb = heap_scan_stream_read_next_serial;
1238
1239 /* ---
1240 * It is safe to use batchmode as the only locks taken by `cb`
1241 * are never taken while waiting for IO:
1242 * - SyncScanLock is used in the non-parallel case
1243 * - in the parallel case, only spinlocks and atomics are used
1244 * ---
1245 */
1247 READ_STREAM_USE_BATCHING,
1248 scan->rs_strategy,
1250 MAIN_FORKNUM,
1251 cb,
1252 scan,
1253 0);
1254 }
1256 {
1258 READ_STREAM_USE_BATCHING,
1259 scan->rs_strategy,
1261 MAIN_FORKNUM,
1263 scan,
1265 }
1266
1267
1269}
static BlockNumber heap_scan_stream_read_next_parallel(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition: heapam.c:250
static BlockNumber heap_scan_stream_read_next_serial(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition: heapam.c:290
static BlockNumber bitmapheap_stream_read_next(ReadStream *pgsr, void *private_data, void *per_buffer_data)
Definition: heapam.c:315
static void initscan(HeapScanDesc scan, ScanKey key, bool keep_startblock)
Definition: heapam.c:355
void PredicateLockRelation(Relation relation, Snapshot snapshot)
Definition: predicate.c:2574
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:2182
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_array, palloc_object, 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 2807 of file heapam.c.
2810{
2811 TM_Result result;
2813 ItemId lp;
2814 HeapTupleData tp;
2815 Page page;
2816 BlockNumber block;
2817 Buffer buffer;
2819 TransactionId new_xmax;
2820 uint16 new_infomask,
2821 new_infomask2;
2822 bool have_tuple_lock = false;
2823 bool iscombo;
2824 bool all_visible_cleared = false;
2826 bool old_key_copied = false;
2827
2829
2830 AssertHasSnapshotForToast(relation);
2831
2832 /*
2833 * Forbid this during a parallel operation, lest it allocate a combo CID.
2834 * Other workers might need that combo CID for visibility checks, and we
2835 * have no provision for broadcasting it to them.
2836 */
2839 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
2841
2842 block = ItemPointerGetBlockNumber(tid);
2843 buffer = ReadBuffer(relation, block);
2844 page = BufferGetPage(buffer);
2845
2846 /*
2847 * Before locking the buffer, pin the visibility map page if it appears to
2848 * be necessary. Since we haven't got the lock yet, someone else might be
2849 * in the middle of changing this, so we'll need to recheck after we have
2850 * the lock.
2851 */
2853 visibilitymap_pin(relation, block, &vmbuffer);
2854
2856
2859
2863 tp.t_self = *tid;
2864
2865l1:
2866
2867 /*
2868 * If we didn't pin the visibility map page and the page has become all
2869 * visible while we were busy locking the buffer, we'll have to unlock and
2870 * re-lock, to avoid holding the buffer lock across an I/O. That's a bit
2871 * unfortunate, but hopefully shouldn't happen often.
2872 */
2874 {
2876 visibilitymap_pin(relation, block, &vmbuffer);
2878 }
2879
2880 result = HeapTupleSatisfiesUpdate(&tp, cid, buffer);
2881
2883 {
2884 UnlockReleaseBuffer(buffer);
2886 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
2888 }
2890 {
2891 TransactionId xwait;
2892 uint16 infomask;
2893
2894 /* must copy state data before unlocking buffer */
2897
2898 /*
2899 * Sleep until concurrent transaction ends -- except when there's a
2900 * single locker and it's our own transaction. Note we don't care
2901 * which lock mode the locker has, because we need the strongest one.
2902 *
2903 * Before sleeping, we need to acquire tuple lock to establish our
2904 * priority for the tuple (see heap_lock_tuple). LockTuple will
2905 * release us when we are next-in-line for the tuple.
2906 *
2907 * If we are forced to "start over" below, we keep the tuple lock;
2908 * this arranges that we stay at the head of the line while rechecking
2909 * tuple state.
2910 */
2912 {
2913 bool current_is_member = false;
2914
2916 LockTupleExclusive, ¤t_is_member))
2917 {
2919
2920 /*
2921 * Acquire the lock, if necessary (but skip it when we're
2922 * requesting a lock and already have one; avoids deadlock).
2923 */
2924 if (!current_is_member)
2926 LockWaitBlock, &have_tuple_lock);
2927
2928 /* wait for multixact */
2931 NULL);
2933
2934 /*
2935 * If xwait had just locked the tuple then some other xact
2936 * could update this tuple before we get to this point. Check
2937 * for xmax change, and start over if so.
2938 *
2939 * We also must start over if we didn't pin the VM page, and
2940 * the page has become all visible.
2941 */
2945 xwait))
2946 goto l1;
2947 }
2948
2949 /*
2950 * You might think the multixact is necessarily done here, but not
2951 * so: it could have surviving members, namely our own xact or
2952 * other subxacts of this backend. It is legal for us to delete
2953 * the tuple in either case, however (the latter case is
2954 * essentially a situation of upgrading our former shared lock to
2955 * exclusive). We don't bother changing the on-disk hint bits
2956 * since we are about to overwrite the xmax altogether.
2957 */
2958 }
2960 {
2961 /*
2962 * Wait for regular transaction to end; but first, acquire tuple
2963 * lock.
2964 */
2967 LockWaitBlock, &have_tuple_lock);
2970
2971 /*
2972 * xwait is done, but if xwait had just locked the tuple then some
2973 * other xact could update this tuple before we get to this point.
2974 * Check for xmax change, and start over if so.
2975 *
2976 * We also must start over if we didn't pin the VM page, and the
2977 * page has become all visible.
2978 */
2982 xwait))
2983 goto l1;
2984
2985 /* Otherwise check if it committed or aborted */
2987 }
2988
2989 /*
2990 * We may overwrite if previous xmax aborted, or if it committed but
2991 * only locked the tuple without updating it.
2992 */
2996 result = TM_Ok;
2998 result = TM_Updated;
2999 else
3000 result = TM_Deleted;
3001 }
3002
3003 /* sanity check the result HeapTupleSatisfiesUpdate() and the logic above */
3005 {
3007 result == TM_Updated ||
3008 result == TM_Deleted ||
3009 result == TM_BeingModified);
3013 }
3014
3016 {
3017 /* Perform additional check for transaction-snapshot mode RI updates */
3019 result = TM_Updated;
3020 }
3021
3023 {
3028 else
3030 UnlockReleaseBuffer(buffer);
3031 if (have_tuple_lock)
3034 ReleaseBuffer(vmbuffer);
3035 return result;
3036 }
3037
3038 /*
3039 * We're about to do the actual delete -- check for conflict first, to
3040 * avoid possibly having to roll back work we've just done.
3041 *
3042 * This is safe without a recheck as long as there is no possibility of
3043 * another process scanning the page between this check and the delete
3044 * being visible to the scan (i.e., an exclusive buffer content lock is
3045 * continuously held from this point until the tuple delete is visible).
3046 */
3048
3049 /* replace cid with a combo CID if necessary */
3051
3052 /*
3053 * Compute replica identity tuple before entering the critical section so
3054 * we don't PANIC upon a memory allocation failure.
3055 */
3057
3058 /*
3059 * If this is the first possibly-multixact-able operation in the current
3060 * transaction, set my per-backend OldestMemberMXactId setting. We can be
3061 * certain that the transaction will never become a member of any older
3062 * MultiXactIds than that. (We have to do this even if we end up just
3063 * using our own TransactionId below, since some other backend could
3064 * incorporate our XID into a MultiXact immediately afterwards.)
3065 */
3066 MultiXactIdSetOldestMember();
3067
3071 &new_xmax, &new_infomask, &new_infomask2);
3072
3073 START_CRIT_SECTION();
3074
3075 /*
3076 * If this transaction commits, the tuple will become DEAD sooner or
3077 * later. Set flag that this page is a candidate for pruning once our xid
3078 * falls below the OldestXmin horizon. If the transaction finally aborts,
3079 * the subsequent page pruning will be a no-op and the hint will be
3080 * cleared.
3081 */
3082 PageSetPrunable(page, xid);
3083
3085 {
3086 all_visible_cleared = true;
3087 PageClearAllVisible(page);
3089 vmbuffer, VISIBILITYMAP_VALID_BITS);
3090 }
3091
3092 /* store transaction information of xact deleting the tuple */
3100 /* Make sure there is no forward chain link in t_ctid */
3102
3103 /* Signal that this is actually a move into another partition */
3104 if (changingPart)
3106
3107 MarkBufferDirty(buffer);
3108
3109 /*
3110 * XLOG stuff
3111 *
3112 * NB: heap_abort_speculative() uses the same xlog record and replay
3113 * routines.
3114 */
3116 {
3117 xl_heap_delete xlrec;
3118 xl_heap_header xlhdr;
3119 XLogRecPtr recptr;
3120
3121 /*
3122 * For logical decode we need combo CIDs to properly decode the
3123 * catalog
3124 */
3126 log_heap_new_cid(relation, &tp);
3127
3128 xlrec.flags = 0;
3129 if (all_visible_cleared)
3131 if (changingPart)
3136 xlrec.xmax = new_xmax;
3137
3138 if (old_key_tuple != NULL)
3139 {
3142 else
3144 }
3145
3146 XLogBeginInsert();
3148
3150
3151 /*
3152 * Log replica identity of the deleted tuple if there is one
3153 */
3154 if (old_key_tuple != NULL)
3155 {
3159
3162 + SizeofHeapTupleHeader,
3163 old_key_tuple->t_len
3164 - SizeofHeapTupleHeader);
3165 }
3166
3167 /* filtering by origin on a row level is much more efficient */
3169
3171
3172 PageSetLSN(page, recptr);
3173 }
3174
3175 END_CRIT_SECTION();
3176
3178
3180 ReleaseBuffer(vmbuffer);
3181
3182 /*
3183 * If the tuple has toasted out-of-line attributes, we need to delete
3184 * those items too. We have to do this before releasing the buffer
3185 * because we need to look at the contents of the tuple, but it's OK to
3186 * release the content lock on the buffer first.
3187 */
3189 relation->rd_rel->relkind != RELKIND_MATVIEW)
3190 {
3191 /* toast table entries should never be recursively toasted */
3193 }
3196
3197 /*
3198 * Mark tuple for invalidation from system caches at next command
3199 * boundary. We have to do this before releasing the buffer because we
3200 * need to look at the contents of the tuple.
3201 */
3202 CacheInvalidateHeapTuple(relation, &tp, NULL);
3203
3204 /* Now we can release the buffer */
3205 ReleaseBuffer(buffer);
3206
3207 /*
3208 * Release the lmgr tuple lock, if we had it.
3209 */
3210 if (have_tuple_lock)
3212
3213 pgstat_count_heap_delete(relation);
3214
3215 if (old_key_tuple != NULL && old_key_copied)
3216 heap_freetuple(old_key_tuple);
3217
3219}
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:7640
static XLogRecPtr log_heap_new_cid(Relation relation, HeapTuple tup)
Definition: heapam.c:9105
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:5359
static bool heap_acquire_tuplock(Relation relation, const ItemPointerData *tid, LockTupleMode mode, LockWaitPolicy wait_policy, bool *have_tuple_lock)
Definition: heapam.c:5310
static HeapTuple ExtractReplicaIdentity(Relation relation, HeapTuple tp, bool key_required, bool *copy)
Definition: heapam.c:9186
static void MultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, Relation rel, const ItemPointerData *ctid, XLTW_Oper oper, int *remaining)
Definition: heapam.c:7818
static bool xmax_infomask_changed(uint16 new_infomask, uint16 old_infomask)
Definition: heapam.c:2784
static void AssertHasSnapshotForToast(Relation rel)
Definition: heapam.c:223
static void UpdateXmaxHintBits(HeapTupleHeader tuple, Buffer buffer, TransactionId xid)
Definition: heapam.c:2017
bool HeapTupleSatisfiesVisibility(HeapTuple htup, Snapshot snapshot, Buffer buffer)
Definition: heapam_visibility.c:1605
bool HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
Definition: heapam_visibility.c:1358
TM_Result HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid, Buffer buffer)
Definition: heapam_visibility.c:433
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:4334
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 1325 of file heapam.c.
1326{
1328
1329 /* Note: no locking manipulations needed */
1330
1331 /*
1332 * unpin scan buffers
1333 */
1336
1337 /*
1338 * Must free the read stream before freeing the BufferAccessStrategy.
1339 */
1342
1343 /*
1344 * decrement relation reference count and free scan descriptor storage
1345 */
1347
1350
1353
1356
1359
1360 pfree(scan);
1361}
void RelationDecrementReferenceCount(Relation rel)
Definition: relcache.c:2195
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 1623 of file heapam.c.
1628{
1630 ItemId lp;
1631 Buffer buffer;
1632 Page page;
1633 OffsetNumber offnum;
1634 bool valid;
1635
1636 /*
1637 * Fetch and pin the appropriate page of the relation.
1638 */
1640
1641 /*
1642 * Need share lock on buffer to examine tuple commit status.
1643 */
1645 page = BufferGetPage(buffer);
1646
1647 /*
1648 * We'd better check for out-of-range offnum in case of VACUUM since the
1649 * TID was obtained.
1650 */
1651 offnum = ItemPointerGetOffsetNumber(tid);
1653 {
1655 ReleaseBuffer(buffer);
1656 *userbuf = InvalidBuffer;
1657 tuple->t_data = NULL;
1658 return false;
1659 }
1660
1661 /*
1662 * get the item line pointer corresponding to the requested tid
1663 */
1664 lp = PageGetItemId(page, offnum);
1665
1666 /*
1667 * Must check for deleted tuple.
1668 */
1670 {
1672 ReleaseBuffer(buffer);
1673 *userbuf = InvalidBuffer;
1674 tuple->t_data = NULL;
1675 return false;
1676 }
1677
1678 /*
1679 * fill in *tuple fields
1680 */
1684
1685 /*
1686 * check tuple visibility, then release lock
1687 */
1688 valid = HeapTupleSatisfiesVisibility(tuple, snapshot, buffer);
1689
1690 if (valid)
1693
1694 HeapCheckForSerializableConflictOut(valid, relation, tuple, buffer, snapshot);
1695
1697
1698 if (valid)
1699 {
1700 /*
1701 * All checks passed, so return the tuple as valid. Caller is now
1702 * responsible for releasing the buffer.
1703 */
1704 *userbuf = buffer;
1705
1706 return true;
1707 }
1708
1709 /* Tuple failed time qual, but maybe caller wants to see it anyway. */
1710 if (keep_buf)
1711 *userbuf = buffer;
1712 else
1713 {
1714 ReleaseBuffer(buffer);
1715 *userbuf = InvalidBuffer;
1716 tuple->t_data = NULL;
1717 }
1718
1719 return false;
1720}
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:9290
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:2619
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 661 of file heapam.c.
662{
664
665 /* release previous scan buffer, if any */
667 {
670 }
671
672 /*
673 * Be sure to check for interrupts at least once per page. Checks at
674 * higher code levels won't be able to stop a seqscan that encounters many
675 * pages' worth of consecutive dead tuples.
676 */
677 CHECK_FOR_INTERRUPTS();
678
679 /*
680 * If the scan direction is changing, reset the prefetch block to the
681 * current block. Otherwise, we will incorrectly prefetch the blocks
682 * between the prefetch block and the current block again before
683 * prefetching blocks in the new, correct scan direction.
684 */
686 {
689 }
690
691 scan->rs_dir = dir;
692
696}
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 6132 of file heapam.c.
6133{
6134 Buffer buffer;
6135 Page page;
6136 OffsetNumber offnum;
6137 ItemId lp;
6138 HeapTupleHeader htup;
6139
6142 page = BufferGetPage(buffer);
6143
6144 offnum = ItemPointerGetOffsetNumber(tid);
6147 lp = PageGetItemId(page, offnum);
6150
6152
6153 /* NO EREPORT(ERROR) from here till changes are logged */
6154 START_CRIT_SECTION();
6155
6157
6158 MarkBufferDirty(buffer);
6159
6160 /*
6161 * Replace the speculative insertion token with a real t_ctid, pointing to
6162 * itself like it does on regular tuples.
6163 */
6164 htup->t_ctid = *tid;
6165
6166 /* XLOG stuff */
6168 {
6169 xl_heap_confirm xlrec;
6170 XLogRecPtr recptr;
6171
6173
6174 XLogBeginInsert();
6175
6176 /* We want the same filtering on this as on a plain insert */
6178
6181
6183
6184 PageSetLSN(page, recptr);
6185 }
6186
6187 END_CRIT_SECTION();
6188
6189 UnlockReleaseBuffer(buffer);
6190}
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 7425 of file heapam.c.
7426{
7428
7430 {
7433 HeapTupleHeader htup;
7434
7436 heap_execute_freeze_tuple(htup, frz);
7437 }
7438}
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 7447 of file heapam.c.
7450{
7451 HeapTupleFreeze frz;
7452 bool do_freeze;
7453 bool totally_frozen;
7455 HeapPageFreeze pagefrz;
7456
7457 cutoffs.relfrozenxid = relfrozenxid;
7458 cutoffs.relminmxid = relminmxid;
7459 cutoffs.OldestXmin = FreezeLimit;
7460 cutoffs.OldestMxact = MultiXactCutoff;
7461 cutoffs.FreezeLimit = FreezeLimit;
7462 cutoffs.MultiXactCutoff = MultiXactCutoff;
7463
7464 pagefrz.freeze_required = true;
7465 pagefrz.FreezePageRelfrozenXid = FreezeLimit;
7466 pagefrz.FreezePageRelminMxid = MultiXactCutoff;
7467 pagefrz.NoFreezePageRelfrozenXid = FreezeLimit;
7468 pagefrz.NoFreezePageRelminMxid = MultiXactCutoff;
7469
7470 do_freeze = heap_prepare_freeze_tuple(tuple, &cutoffs,
7471 &pagefrz, &frz, &totally_frozen);
7472
7473 /*
7474 * Note that because this is not a WAL-logged operation, we don't need to
7475 * fill in the offset in the freeze record.
7476 */
7477
7478 if (do_freeze)
7479 heap_execute_freeze_tuple(tuple, &frz);
7480 return do_freeze;
7481}
bool heap_prepare_freeze_tuple(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen)
Definition: heapam.c:7099
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 1895 of file heapam.c.
1897{
1900 ItemPointerData ctid;
1901 TransactionId priorXmax;
1902
1903 /*
1904 * table_tuple_get_latest_tid() verified that the passed in tid is valid.
1905 * Assume that t_ctid links are valid however - there shouldn't be invalid
1906 * ones in the table.
1907 */
1909
1910 /*
1911 * Loop to chase down t_ctid links. At top of loop, ctid is the tuple we
1912 * need to examine, and *tid is the TID we will return if ctid turns out
1913 * to be bogus.
1914 *
1915 * Note that we will loop until we reach the end of the t_ctid chain.
1916 * Depending on the snapshot passed, there might be at most one visible
1917 * version of the row, but we don't try to optimize for that.
1918 */
1919 ctid = *tid;
1921 for (;;)
1922 {
1923 Buffer buffer;
1924 Page page;
1925 OffsetNumber offnum;
1926 ItemId lp;
1927 HeapTupleData tp;
1928 bool valid;
1929
1930 /*
1931 * Read, pin, and lock the page.
1932 */
1935 page = BufferGetPage(buffer);
1936
1937 /*
1938 * Check for bogus item number. This is not treated as an error
1939 * condition because it can happen while following a t_ctid link. We
1940 * just assume that the prior tid is OK and return it unchanged.
1941 */
1942 offnum = ItemPointerGetOffsetNumber(&ctid);
1944 {
1945 UnlockReleaseBuffer(buffer);
1946 break;
1947 }
1948 lp = PageGetItemId(page, offnum);
1950 {
1951 UnlockReleaseBuffer(buffer);
1952 break;
1953 }
1954
1955 /* OK to access the tuple */
1956 tp.t_self = ctid;
1960
1961 /*
1962 * After following a t_ctid link, we might arrive at an unrelated
1963 * tuple. Check for XMIN match.
1964 */
1967 {
1968 UnlockReleaseBuffer(buffer);
1969 break;
1970 }
1971
1972 /*
1973 * Check tuple visibility; if visible, set it as the new result
1974 * candidate.
1975 */
1976 valid = HeapTupleSatisfiesVisibility(&tp, snapshot, buffer);
1977 HeapCheckForSerializableConflictOut(valid, relation, &tp, buffer, snapshot);
1978 if (valid)
1979 *tid = ctid;
1980
1981 /*
1982 * If there's a valid t_ctid link, follow it, else we're done.
1983 */
1988 {
1989 UnlockReleaseBuffer(buffer);
1990 break;
1991 }
1992
1995 UnlockReleaseBuffer(buffer);
1996 } /* end of loop */
1997}
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 1364 of file heapam.c.
1365{
1367
1368 /*
1369 * This is still widely used directly, without going through table AM, so
1370 * add a safety check. It's possible we should, at a later point,
1371 * downgrade this to an assert. The reason for checking the AM routine,
1372 * rather than the AM oid, is that this allows to write regression tests
1373 * that create another AM reusing the heap handler.
1374 */
1377 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1379
1380 /*
1381 * We don't expect direct calls to heap_getnext with valid CheckXidAlive
1382 * for catalog or regular tables. See detailed comments in xact.c where
1383 * these variables are declared. Normally we have such a check at tableam
1384 * level API but this is called from many places so we need to ensure it
1385 * here.
1386 */
1389
1390 /* Note: no locking manipulations needed */
1391
1393 heapgettup_pagemode(scan, direction,
1395 else
1396 heapgettup(scan, direction,
1398
1400 return NULL;
1401
1402 /*
1403 * if we get here it means we have a new current scan tuple, so point to
1404 * the proper return buffer and return the tuple.
1405 */
1406
1408
1410}
static void heapgettup(HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
Definition: heapam.c:914
static void heapgettup_pagemode(HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
Definition: heapam.c:1024
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 1413 of file heapam.c.
1414{
1416
1417 /* Note: no locking manipulations needed */
1418
1421 else
1423
1425 {
1426 ExecClearTuple(slot);
1427 return false;
1428 }
1429
1430 /*
1431 * if we get here it means we have a new current scan tuple, so point to
1432 * the proper return buffer and return the tuple.
1433 */
1434
1436
1438 scan->rs_cbuf);
1439 return true;
1440}
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 1516 of file heapam.c.
1518{
1522
1523 /* Note: no locking manipulations needed */
1524 for (;;)
1525 {
1528 else
1530
1532 {
1533 ExecClearTuple(slot);
1534 return false;
1535 }
1536
1537 /*
1538 * heap_set_tidrange will have used heap_setscanlimits to limit the
1539 * range of pages we scan to only ones that can contain the TID range
1540 * we're scanning for. Here we must filter out any tuples from these
1541 * pages that are outside of that range.
1542 */
1544 {
1545 ExecClearTuple(slot);
1546
1547 /*
1548 * When scanning backwards, the TIDs will be in descending order.
1549 * Future tuples in this direction will be lower still, so we can
1550 * just return false to indicate there will be no more tuples.
1551 */
1553 return false;
1554
1555 continue;
1556 }
1557
1558 /*
1559 * Likewise for the final page, we must filter out TIDs greater than
1560 * maxtid.
1561 */
1563 {
1564 ExecClearTuple(slot);
1565
1566 /*
1567 * When scanning forward, the TIDs will be in ascending order.
1568 * Future tuples in this direction will be higher still, so we can
1569 * just return false to indicate there will be no more tuples.
1570 */
1572 return false;
1573 continue;
1574 }
1575
1576 break;
1577 }
1578
1579 /*
1580 * if we get here it means we have a new current scan tuple, so point to
1581 * the proper return buffer and return the tuple.
1582 */
1584
1586 return true;
1587}
int32 ItemPointerCompare(const ItemPointerData *arg1, const ItemPointerData *arg2)
Definition: itemptr.c:51
struct TableScanDescData::@49::@50 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 1743 of file heapam.c.
1746{
1749 BlockNumber blkno;
1750 OffsetNumber offnum;
1751 bool at_chain_start;
1752 bool valid;
1754 GlobalVisState *vistest = NULL;
1755
1756 /* If this is not the first call, previous call returned a (live!) tuple */
1757 if (all_dead)
1758 *all_dead = first_call;
1759
1760 blkno = ItemPointerGetBlockNumber(tid);
1761 offnum = ItemPointerGetOffsetNumber(tid);
1762 at_chain_start = first_call;
1763 skip = !first_call;
1764
1765 /* XXX: we should assert that a snapshot is pushed or registered */
1768
1769 /* Scan through possible multiple members of HOT-chain */
1770 for (;;)
1771 {
1772 ItemId lp;
1773
1774 /* check for bogus TID */
1776 break;
1777
1778 lp = PageGetItemId(page, offnum);
1779
1780 /* check for unused, dead, or redirected items */
1782 {
1783 /* We should only see a redirect at start of chain */
1785 {
1786 /* Follow the redirect */
1787 offnum = ItemIdGetRedirect(lp);
1788 at_chain_start = false;
1789 continue;
1790 }
1791 /* else must be end of chain */
1792 break;
1793 }
1794
1795 /*
1796 * Update heapTuple to point to the element of the HOT chain we're
1797 * currently investigating. Having t_self set correctly is important
1798 * because the SSI checks and the *Satisfies routine for historical
1799 * MVCC snapshots need the correct tid to decide about the visibility.
1800 */
1805
1806 /*
1807 * Shouldn't see a HEAP_ONLY tuple at chain start.
1808 */
1810 break;
1811
1812 /*
1813 * The xmin should match the previous xmax value, else chain is
1814 * broken.
1815 */
1817 !TransactionIdEquals(prev_xmax,
1819 break;
1820
1821 /*
1822 * When first_call is true (and thus, skip is initially false) we'll
1823 * return the first tuple we find. But on later passes, heapTuple
1824 * will initially be pointing to the tuple we returned last time.
1825 * Returning it again would be incorrect (and would loop forever), so
1826 * we skip it and return the next match we find.
1827 */
1829 {
1830 /* If it's visible per the snapshot, we must return it */
1831 valid = HeapTupleSatisfiesVisibility(heapTuple, snapshot, buffer);
1832 HeapCheckForSerializableConflictOut(valid, relation, heapTuple,
1833 buffer, snapshot);
1834
1835 if (valid)
1836 {
1837 ItemPointerSetOffsetNumber(tid, offnum);
1840 if (all_dead)
1841 *all_dead = false;
1842 return true;
1843 }
1844 }
1846
1847 /*
1848 * If we can't see it, maybe no one else can either. At caller
1849 * request, check whether all chain members are dead to all
1850 * transactions.
1851 *
1852 * Note: if you change the criterion here for what is "dead", fix the
1853 * planner's get_actual_variable_range() function to match.
1854 */
1855 if (all_dead && *all_dead)
1856 {
1857 if (!vistest)
1858 vistest = GlobalVisTestFor(relation);
1859
1861 *all_dead = false;
1862 }
1863
1864 /*
1865 * Check to see if HOT chain continues past this tuple; if so fetch
1866 * the next offnum and loop around.
1867 */
1869 {
1871 blkno);
1873 at_chain_start = false;
1875 }
1876 else
1877 break; /* end of chain */
1878 }
1879
1880 return false;
1881}
bool HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
Definition: heapam_visibility.c:1303
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:170
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 8163 of file heapam.c.
8164{
8165 /* Initial assumption is that earlier pruning took care of conflict */
8169 Page page = NULL;
8171 TransactionId priorXmax;
8172#ifdef USE_PREFETCH
8173 IndexDeletePrefetchState prefetch_state;
8174 int prefetch_distance;
8175#endif
8176 SnapshotData SnapshotNonVacuumable;
8177 int finalndeltids = 0,
8178 nblocksaccessed = 0;
8179
8180 /* State that's only used in bottom-up index deletion case */
8181 int nblocksfavorable = 0;
8183 lastfreespace = 0,
8184 actualfreespace = 0;
8185 bool bottomup_final_block = false;
8186
8188
8189 /* Sort caller's deltids array by TID for further processing */
8190 index_delete_sort(delstate);
8191
8192 /*
8193 * Bottom-up case: resort deltids array in an order attuned to where the
8194 * greatest number of promising TIDs are to be found, and determine how
8195 * many blocks from the start of sorted array should be considered
8196 * favorable. This will also shrink the deltids array in order to
8197 * eliminate completely unfavorable blocks up front.
8198 */
8200 nblocksfavorable = bottomup_sort_and_shrink(delstate);
8201
8202#ifdef USE_PREFETCH
8203 /* Initialize prefetch state. */
8204 prefetch_state.cur_hblkno = InvalidBlockNumber;
8205 prefetch_state.next_item = 0;
8206 prefetch_state.ndeltids = delstate->ndeltids;
8207 prefetch_state.deltids = delstate->deltids;
8208
8209 /*
8210 * Determine the prefetch distance that we will attempt to maintain.
8211 *
8212 * Since the caller holds a buffer lock somewhere in rel, we'd better make
8213 * sure that isn't a catalog relation before we call code that does
8214 * syscache lookups, to avoid risk of deadlock.
8215 */
8217 prefetch_distance = maintenance_io_concurrency;
8218 else
8219 prefetch_distance =
8221
8222 /* Cap initial prefetch distance for bottom-up deletion caller */
8224 {
8225 Assert(nblocksfavorable >= 1);
8227 prefetch_distance = Min(prefetch_distance, nblocksfavorable);
8228 }
8229
8230 /* Start prefetching. */
8231 index_delete_prefetch_buffer(rel, &prefetch_state, prefetch_distance);
8232#endif
8233
8234 /* Iterate over deltids, determine which to delete, check their horizon */
8237 {
8241 OffsetNumber offnum;
8242
8243 /*
8244 * Read buffer, and perform required extra steps each time a new block
8245 * is encountered. Avoid refetching if it's the same block as the one
8246 * from the last htid.
8247 */
8249 ItemPointerGetBlockNumber(htid) != blkno)
8250 {
8251 /*
8252 * Consider giving up early for bottom-up index deletion caller
8253 * first. (Only prefetch next-next block afterwards, when it
8254 * becomes clear that we're at least going to access the next
8255 * block in line.)
8256 *
8257 * Sometimes the first block frees so much space for bottom-up
8258 * caller that the deletion process can end without accessing any
8259 * more blocks. It is usually necessary to access 2 or 3 blocks
8260 * per bottom-up deletion operation, though.
8261 */
8263 {
8264 /*
8265 * We often allow caller to delete a few additional items
8266 * whose entries we reached after the point that space target
8267 * from caller was satisfied. The cost of accessing the page
8268 * was already paid at that point, so it made sense to finish
8269 * it off. When that happened, we finalize everything here
8270 * (by finishing off the whole bottom-up deletion operation
8271 * without needlessly paying the cost of accessing any more
8272 * blocks).
8273 */
8274 if (bottomup_final_block)
8275 break;
8276
8277 /*
8278 * Give up when we didn't enable our caller to free any
8279 * additional space as a result of processing the page that we
8280 * just finished up with. This rule is the main way in which
8281 * we keep the cost of bottom-up deletion under control.
8282 */
8283 if (nblocksaccessed >= 1 && actualfreespace == lastfreespace)
8284 break;
8285 lastfreespace = actualfreespace; /* for next time */
8286
8287 /*
8288 * Deletion operation (which is bottom-up) will definitely
8289 * access the next block in line. Prepare for that now.
8290 *
8291 * Decay target free space so that we don't hang on for too
8292 * long with a marginal case. (Space target is only truly
8293 * helpful when it allows us to recognize that we don't need
8294 * to access more than 1 or 2 blocks to satisfy caller due to
8295 * agreeable workload characteristics.)
8296 *
8297 * We are a bit more patient when we encounter contiguous
8298 * blocks, though: these are treated as favorable blocks. The
8299 * decay process is only applied when the next block in line
8300 * is not a favorable/contiguous block. This is not an
8301 * exception to the general rule; we still insist on finding
8302 * at least one deletable item per block accessed. See
8303 * bottomup_nblocksfavorable() for full details of the theory
8304 * behind favorable blocks and heap block locality in general.
8305 *
8306 * Note: The first block in line is always treated as a
8307 * favorable block, so the earliest possible point that the
8308 * decay can be applied is just before we access the second
8309 * block in line. The Assert() verifies this for us.
8310 */
8311 Assert(nblocksaccessed > 0 || nblocksfavorable > 0);
8312 if (nblocksfavorable > 0)
8313 nblocksfavorable--;
8314 else
8315 curtargetfreespace /= 2;
8316 }
8317
8318 /* release old buffer */
8321
8322 blkno = ItemPointerGetBlockNumber(htid);
8324 nblocksaccessed++;
8326 nblocksaccessed <= BOTTOMUP_MAX_NBLOCKS);
8327
8328#ifdef USE_PREFETCH
8329
8330 /*
8331 * To maintain the prefetch distance, prefetch one more page for
8332 * each page we read.
8333 */
8334 index_delete_prefetch_buffer(rel, &prefetch_state, 1);
8335#endif
8336
8338
8340 maxoff = PageGetMaxOffsetNumber(page);
8341 }
8342
8343 /*
8344 * In passing, detect index corruption involving an index page with a
8345 * TID that points to a location in the heap that couldn't possibly be
8346 * correct. We only do this with actual TIDs from caller's index page
8347 * (not items reached by traversing through a HOT chain).
8348 */
8349 index_delete_check_htid(delstate, page, maxoff, htid, istatus);
8350
8353 else
8354 {
8355 ItemPointerData tmp = *htid;
8356 HeapTupleData heapTuple;
8357
8358 /* Are any tuples from this HOT chain non-vacuumable? */
8360 &heapTuple, NULL, true))
8361 continue; /* can't delete entry */
8362
8363 /* Caller will delete, since whole HOT chain is vacuumable */
8365
8366 /* Maintain index free space info for bottom-up deletion case */
8368 {
8370 actualfreespace += istatus->freespace;
8371 if (actualfreespace >= curtargetfreespace)
8372 bottomup_final_block = true;
8373 }
8374 }
8375
8376 /*
8377 * Maintain snapshotConflictHorizon value for deletion operation as a
8378 * whole by advancing current value using heap tuple headers. This is
8379 * loosely based on the logic for pruning a HOT chain.
8380 */
8381 offnum = ItemPointerGetOffsetNumber(htid);
8383 for (;;)
8384 {
8385 ItemId lp;
8386 HeapTupleHeader htup;
8387
8388 /* Sanity check (pure paranoia) */
8390 break;
8391
8392 /*
8393 * An offset past the end of page's line pointer array is possible
8394 * when the array was truncated
8395 */
8396 if (offnum > maxoff)
8397 break;
8398
8399 lp = PageGetItemId(page, offnum);
8401 {
8402 offnum = ItemIdGetRedirect(lp);
8403 continue;
8404 }
8405
8406 /*
8407 * We'll often encounter LP_DEAD line pointers (especially with an
8408 * entry marked knowndeletable by our caller up front). No heap
8409 * tuple headers get examined for an htid that leads us to an
8410 * LP_DEAD item. This is okay because the earlier pruning
8411 * operation that made the line pointer LP_DEAD in the first place
8412 * must have considered the original tuple header as part of
8413 * generating its own snapshotConflictHorizon value.
8414 *
8415 * Relying on XLOG_HEAP2_PRUNE_VACUUM_SCAN records like this is
8416 * the same strategy that index vacuuming uses in all cases. Index
8417 * VACUUM WAL records don't even have a snapshotConflictHorizon
8418 * field of their own for this reason.
8419 */
8421 break;
8422
8424
8425 /*
8426 * Check the tuple XMIN against prior XMAX, if any
8427 */
8430 break;
8431
8432 HeapTupleHeaderAdvanceConflictHorizon(htup,
8433 &snapshotConflictHorizon);
8434
8435 /*
8436 * If the tuple is not HOT-updated, then we are at the end of this
8437 * HOT-chain. No need to visit later tuples from the same update
8438 * chain (they get their own index entries) -- just move on to
8439 * next htid from index AM caller.
8440 */
8442 break;
8443
8444 /* Advance to next HOT chain member */
8447 priorXmax = HeapTupleHeaderGetUpdateXid(htup);
8448 }
8449
8450 /* Enable further/final shrinking of deltids for caller */
8451 finalndeltids = i + 1;
8452 }
8453
8455
8456 /*
8457 * Shrink deltids array to exclude non-deletable entries at the end. This
8458 * is not just a minor optimization. Final deltids array size might be
8459 * zero for a bottom-up caller. Index AM is explicitly allowed to rely on
8460 * ndeltids being zero in all cases with zero total deletable entries.
8461 */
8463 delstate->ndeltids = finalndeltids;
8464
8465 return snapshotConflictHorizon;
8466}
static int bottomup_sort_and_shrink(TM_IndexDeleteOp *delstate)
Definition: heapam.c:8720
void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)
Definition: heapam.c:8018
static void index_delete_check_htid(TM_IndexDeleteOp *delstate, Page page, OffsetNumber maxoff, const ItemPointerData *htid, TM_IndexStatus *istatus)
Definition: heapam.c:8103
bool heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, bool *all_dead, bool first_call)
Definition: heapam.c:1743
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 6401 of file heapam.c.
6404{
6406 TM_Result result;
6407 bool ret;
6408
6409#ifdef USE_ASSERT_CHECKING
6411 check_inplace_rel_lock(oldtup_ptr);
6412#endif
6413
6415
6416 /*
6417 * Register shared cache invals if necessary. Other sessions may finish
6418 * inplace updates of this tuple between this step and LockTuple(). Since
6419 * inplace updates don't change cache keys, that's harmless.
6420 *
6421 * While it's tempting to register invals only after confirming we can
6422 * return true, the following obstacle precludes reordering steps that
6423 * way. Registering invals might reach a CatalogCacheInitializeCache()
6424 * that locks "buffer". That would hang indefinitely if running after our
6425 * own LockBuffer(). Hence, we must register invals before LockBuffer().
6426 */
6427 CacheInvalidateHeapTupleInplace(relation, oldtup_ptr);
6428
6431
6432 /*----------
6433 * Interpret HeapTupleSatisfiesUpdate() like heap_update() does, except:
6434 *
6435 * - wait unconditionally
6436 * - already locked tuple above, since inplace needs that unconditionally
6437 * - don't recheck header after wait: simpler to defer to next iteration
6438 * - don't try to continue even if the updater aborts: likewise
6439 * - no crosscheck
6440 */
6442 buffer);
6443
6445 {
6446 /* no known way this can happen */
6448 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
6450 }
6452 {
6453 /*
6454 * CREATE INDEX might reach this if an expression is silly enough to
6455 * call e.g. SELECT ... FROM pg_class FOR SHARE. C code of other SQL
6456 * statements might get here after a heap_update() of the same row, in
6457 * the absence of an intervening CommandCounterIncrement().
6458 */
6460 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
6461 errmsg("tuple to be updated was already modified by an operation triggered by the current command")));
6462 }
6464 {
6465 TransactionId xwait;
6466 uint16 infomask;
6467
6470
6472 {
6475 int remain;
6476
6478 lockmode, NULL))
6479 {
6481 release_callback(arg);
6482 ret = false;
6485 &remain);
6486 }
6487 else
6488 ret = true;
6489 }
6491 ret = true;
6493 ret = true;
6494 else
6495 {
6497 release_callback(arg);
6498 ret = false;
6500 XLTW_Update);
6501 }
6502 }
6503 else
6504 {
6505 ret = (result == TM_Ok);
6506 if (!ret)
6507 {
6509 release_callback(arg);
6510 }
6511 }
6512
6513 /*
6514 * GetCatalogSnapshot() relies on invalidation messages to know when to
6515 * take a new snapshot. COMMIT of xwait is responsible for sending the
6516 * invalidation. We're not acquiring heavyweight locks sufficient to
6517 * block if not yet sent, so we must take a new snapshot to ensure a later
6518 * attempt has a fair chance. While we don't need this if xwait aborted,
6519 * don't bother optimizing that.
6520 */
6521 if (!ret)
6522 {
6524 ForgetInplace_Inval();
6525 InvalidateCatalogSnapshot();
6526 }
6527 return ret;
6528}
void CacheInvalidateHeapTupleInplace(Relation relation, HeapTuple key_equivalent_tuple)
Definition: inval.c:1593
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 6688 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 6539 of file heapam.c.
6542{
6544 uint32 oldlen;
6545 uint32 newlen;
6546 char *dst;
6547 char *src;
6548 int nmsgs = 0;
6549 SharedInvalidationMessage *invalMessages = NULL;
6550 bool RelcacheInitFileInval = false;
6551
6557
6560
6561 /* Like RecordTransactionCommit(), log only if needed */
6563 nmsgs = inplaceGetInvalidationMessages(&invalMessages,
6564 &RelcacheInitFileInval);
6565
6566 /*
6567 * Unlink relcache init files as needed. If unlinking, acquire
6568 * RelCacheInitLock until after associated invalidations. By doing this
6569 * in advance, if we checkpoint and then crash between inplace
6570 * XLogInsert() and inval, we don't rely on StartupXLOG() ->
6571 * RelationCacheInitFileRemove(). That uses elevel==LOG, so replay would
6572 * neglect to PANIC on EIO.
6573 */
6574 PreInplace_Inval();
6575
6576 /*----------
6577 * NO EREPORT(ERROR) from here till changes are complete
6578 *
6579 * Our buffer lock won't stop a reader having already pinned and checked
6580 * visibility for this tuple. Hence, we write WAL first, then mutate the
6581 * buffer. Like in MarkBufferDirtyHint() or RecordTransactionCommit(),
6582 * checkpoint delay makes that acceptable. With the usual order of
6583 * changes, a crash after memcpy() and before XLogInsert() could allow
6584 * datfrozenxid to overtake relfrozenxid:
6585 *
6586 * ["D" is a VACUUM (ONLY_DATABASE_STATS)]
6587 * ["R" is a VACUUM tbl]
6588 * D: vac_update_datfrozenxid() -> systable_beginscan(pg_class)
6589 * D: systable_getnext() returns pg_class tuple of tbl
6590 * R: memcpy() into pg_class tuple of tbl
6591 * D: raise pg_database.datfrozenxid, XLogInsert(), finish
6592 * [crash]
6593 * [recovery restores datfrozenxid w/o relfrozenxid]
6594 *
6595 * Mimic MarkBufferDirtyHint() subroutine XLogSaveBufferForHint().
6596 * Specifically, use DELAY_CHKPT_START, and copy the buffer to the stack.
6597 * The stack copy facilitates a FPI of the post-mutation block before we
6598 * accept other sessions seeing it. DELAY_CHKPT_START allows us to
6599 * XLogInsert() before MarkBufferDirty(). Since XLogSaveBufferForHint()
6600 * can operate under BUFFER_LOCK_SHARED, it can't avoid DELAY_CHKPT_START.
6601 * This function, however, likely could avoid it with the following order
6602 * of operations: MarkBufferDirty(), XLogInsert(), memcpy(). Opt to use
6603 * DELAY_CHKPT_START here, too, as a way to have fewer distinct code
6604 * patterns to analyze. Inplace update isn't so frequent that it should
6605 * pursue the small optimization of skipping DELAY_CHKPT_START.
6606 */
6608 START_CRIT_SECTION();
6610
6611 /* XLOG stuff */
6613 {
6614 xl_heap_inplace xlrec;
6615 PGAlignedBlock copied_buffer;
6620 uintptr_t dst_offset_in_block;
6621 RelFileLocator rlocator;
6622 ForkNumber forkno;
6623 BlockNumber blkno;
6624 XLogRecPtr recptr;
6625
6629 xlrec.relcacheInitFileInval = RelcacheInitFileInval;
6630 xlrec.nmsgs = nmsgs;
6631
6632 XLogBeginInsert();
6634 if (nmsgs != 0)
6635 XLogRegisterData(invalMessages,
6637
6638 /* register block matching what buffer will look like after changes */
6641 dst_offset_in_block = dst - origdata;
6642 memcpy(copied_buffer.data + dst_offset_in_block, src, newlen);
6643 BufferGetTag(buffer, &rlocator, &forkno, &blkno);
6646 REGBUF_STANDARD);
6647 XLogRegisterBufData(0, src, newlen);
6648
6649 /* inplace updates aren't decoded atm, don't log the origin */
6650
6652
6653 PageSetLSN(page, recptr);
6654 }
6655
6656 memcpy(dst, src, newlen);
6657
6658 MarkBufferDirty(buffer);
6659
6661
6662 /*
6663 * Send invalidations to shared queue. SearchSysCacheLocked1() assumes we
6664 * do this before UnlockTuple().
6665 */
6666 AtInplace_Inval();
6667
6669 END_CRIT_SECTION();
6671
6673
6674 /*
6675 * Queue a transactional inval, for logical decoding and for third-party
6676 * code that might have been relying on it since long before inplace
6677 * update adopted immediate invalidation. See README.tuplock section
6678 * "Reading inplace-updated columns" for logical decoding details.
6679 */
6681 CacheInvalidateHeapTuple(relation, tuple, NULL);
6682}
void BufferGetTag(Buffer buffer, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum)
Definition: bufmgr.c:4339
int inplaceGetInvalidationMessages(SharedInvalidationMessage **msgs, bool *RelcacheInitFileInval)
Definition: inval.c:1088
Definition: c.h:1115
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 2106 of file heapam.c.
2108{
2110 HeapTuple heaptup;
2111 Buffer buffer;
2113 bool all_visible_cleared = false;
2114
2115 /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
2117 RelationGetNumberOfAttributes(relation));
2118
2119 AssertHasSnapshotForToast(relation);
2120
2121 /*
2122 * Fill in tuple header fields and toast the tuple if necessary.
2123 *
2124 * Note: below this point, heaptup is the data we actually intend to store
2125 * into the relation; tup is the caller's original untoasted data.
2126 */
2128
2129 /*
2130 * Find buffer to insert this tuple into. If the page is all visible,
2131 * this will also pin the requisite visibility map page.
2132 */
2135 &vmbuffer, NULL,
2136 0);
2137
2138 /*
2139 * We're about to do the actual insert -- but check for conflict first, to
2140 * avoid possibly having to roll back work we've just done.
2141 *
2142 * This is safe without a recheck as long as there is no possibility of
2143 * another process scanning the page between this check and the insert
2144 * being visible to the scan (i.e., an exclusive buffer content lock is
2145 * continuously held from this point until the tuple insert is visible).
2146 *
2147 * For a heap insert, we only need to check for table-level SSI locks. Our
2148 * new tuple can't possibly conflict with existing tuple locks, and heap
2149 * page locks are only consolidated versions of tuple locks; they do not
2150 * lock "gaps" as index page locks do. So we don't need to specify a
2151 * buffer when making the call, which makes for a faster check.
2152 */
2154
2155 /* NO EREPORT(ERROR) from here till changes are logged */
2156 START_CRIT_SECTION();
2157
2158 RelationPutHeapTuple(relation, buffer, heaptup,
2160
2162 {
2163 all_visible_cleared = true;
2165 visibilitymap_clear(relation,
2167 vmbuffer, VISIBILITYMAP_VALID_BITS);
2168 }
2169
2170 /*
2171 * XXX Should we set PageSetPrunable on this page ?
2172 *
2173 * The inserting transaction may eventually abort thus making this tuple
2174 * DEAD and hence available for pruning. Though we don't want to optimize
2175 * for aborts, if no other tuple in this page is UPDATEd/DELETEd, the
2176 * aborted tuple will never be pruned until next vacuum is triggered.
2177 *
2178 * If you do add PageSetPrunable here, add it in heap_xlog_insert too.
2179 */
2180
2181 MarkBufferDirty(buffer);
2182
2183 /* XLOG stuff */
2185 {
2186 xl_heap_insert xlrec;
2187 xl_heap_header xlhdr;
2188 XLogRecPtr recptr;
2191 int bufflags = 0;
2192
2193 /*
2194 * If this is a catalog, we need to transmit combo CIDs to properly
2195 * decode, so log that as well.
2196 */
2198 log_heap_new_cid(relation, heaptup);
2199
2200 /*
2201 * If this is the single and first tuple on page, we can reinit the
2202 * page instead of restoring the whole thing. Set flag, and hide
2203 * buffer references from XLogInsert.
2204 */
2207 {
2208 info |= XLOG_HEAP_INIT_PAGE;
2209 bufflags |= REGBUF_WILL_INIT;
2210 }
2211
2213 xlrec.flags = 0;
2214 if (all_visible_cleared)
2219
2220 /*
2221 * For logical decoding, we need the tuple even if we're doing a full
2222 * page write, so make sure it's included even if we take a full-page
2223 * image. (XXX We could alternatively store a pointer into the FPW).
2224 */
2227 {
2229 bufflags |= REGBUF_KEEP_DATA;
2230
2233 }
2234
2235 XLogBeginInsert();
2237
2241
2242 /*
2243 * note we mark xlhdr as belonging to buffer; if XLogInsert decides to
2244 * write the whole page to the xlog, we don't need to store
2245 * xl_heap_header in the xlog.
2246 */
2249 /* PG73FORMAT: write bitmap [+ padding] [+ oid] + data */
2250 XLogRegisterBufData(0,
2253
2254 /* filtering by origin on a row level is much more efficient */
2256
2257 recptr = XLogInsert(RM_HEAP_ID, info);
2258
2259 PageSetLSN(page, recptr);
2260 }
2261
2262 END_CRIT_SECTION();
2263
2264 UnlockReleaseBuffer(buffer);
2266 ReleaseBuffer(vmbuffer);
2267
2268 /*
2269 * If tuple is cacheable, mark it for invalidation from the caches in case
2270 * we abort. Note it is OK to do this after releasing the buffer, because
2271 * the heaptup data structure is all in local memory, not in the shared
2272 * buffer.
2273 */
2274 CacheInvalidateHeapTuple(relation, heaptup, NULL);
2275
2276 /* Note: speculative insertions are counted too, even if aborted later */
2277 pgstat_count_heap_insert(relation, 1);
2278
2279 /*
2280 * If heaptup is a private copy, release it. Don't forget to copy t_self
2281 * back to the caller's image, too.
2282 */
2283 if (heaptup != tup)
2284 {
2286 heap_freetuple(heaptup);
2287 }
2288}
static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid, CommandId cid, int options)
Definition: heapam.c:2297
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:373
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 4608 of file heapam.c.
4612{
4613 TM_Result result;
4615 ItemId lp;
4616 Page page;
4618 BlockNumber block;
4619 TransactionId xid,
4620 xmax;
4621 uint16 old_infomask,
4622 new_infomask,
4623 new_infomask2;
4624 bool first_time = true;
4625 bool skip_tuple_lock = false;
4626 bool have_tuple_lock = false;
4627 bool cleared_all_frozen = false;
4628
4630 block = ItemPointerGetBlockNumber(tid);
4631
4632 /*
4633 * Before locking the buffer, pin the visibility map page if it appears to
4634 * be necessary. Since we haven't got the lock yet, someone else might be
4635 * in the middle of changing this, so we'll need to recheck after we have
4636 * the lock.
4637 */
4639 visibilitymap_pin(relation, block, &vmbuffer);
4640
4642
4643 page = BufferGetPage(*buffer);
4646
4650
4651l3:
4652 result = HeapTupleSatisfiesUpdate(tuple, cid, *buffer);
4653
4655 {
4656 /*
4657 * This is possible, but only when locking a tuple for ON CONFLICT
4658 * UPDATE. We return this value here rather than throwing an error in
4659 * order to give that case the opportunity to throw a more specific
4660 * error.
4661 */
4662 result = TM_Invisible;
4663 goto out_locked;
4664 }
4666 result == TM_Updated ||
4667 result == TM_Deleted)
4668 {
4669 TransactionId xwait;
4670 uint16 infomask;
4671 uint16 infomask2;
4672 bool require_sleep;
4673 ItemPointerData t_ctid;
4674
4675 /* must copy state data before unlocking buffer */
4680
4682
4683 /*
4684 * If any subtransaction of the current top transaction already holds
4685 * a lock as strong as or stronger than what we're requesting, we
4686 * effectively hold the desired lock already. We *must* succeed
4687 * without trying to take the tuple lock, else we will deadlock
4688 * against anyone wanting to acquire a stronger lock.
4689 *
4690 * Note we only do this the first time we loop on the HTSU result;
4691 * there is no point in testing in subsequent passes, because
4692 * evidently our own transaction cannot have acquired a new lock after
4693 * the first time we checked.
4694 */
4695 if (first_time)
4696 {
4697 first_time = false;
4698
4700 {
4702 int nmembers;
4703 MultiXactMember *members;
4704
4705 /*
4706 * We don't need to allow old multixacts here; if that had
4707 * been the case, HeapTupleSatisfiesUpdate would have returned
4708 * MayBeUpdated and we wouldn't be here.
4709 */
4710 nmembers =
4712 HEAP_XMAX_IS_LOCKED_ONLY(infomask));
4713
4715 {
4716 /* only consider members of our own transaction */
4718 continue;
4719
4721 {
4722 pfree(members);
4723 result = TM_Ok;
4724 goto out_unlocked;
4725 }
4726 else
4727 {
4728 /*
4729 * Disable acquisition of the heavyweight tuple lock.
4730 * Otherwise, when promoting a weaker lock, we might
4731 * deadlock with another locker that has acquired the
4732 * heavyweight tuple lock and is waiting for our
4733 * transaction to finish.
4734 *
4735 * Note that in this case we still need to wait for
4736 * the multixact if required, to avoid acquiring
4737 * conflicting locks.
4738 */
4739 skip_tuple_lock = true;
4740 }
4741 }
4742
4743 if (members)
4744 pfree(members);
4745 }
4747 {
4749 {
4752 HEAP_XMAX_IS_SHR_LOCKED(infomask) ||
4753 HEAP_XMAX_IS_EXCL_LOCKED(infomask));
4754 result = TM_Ok;
4755 goto out_unlocked;
4758 HEAP_XMAX_IS_EXCL_LOCKED(infomask))
4759 {
4760 result = TM_Ok;
4761 goto out_unlocked;
4762 }
4763 break;
4766 {
4767 result = TM_Ok;
4768 goto out_unlocked;
4769 }
4770 break;
4773 infomask2 & HEAP_KEYS_UPDATED)
4774 {
4775 result = TM_Ok;
4776 goto out_unlocked;
4777 }
4778 break;
4779 }
4780 }
4781 }
4782
4783 /*
4784 * Initially assume that we will have to wait for the locking
4785 * transaction(s) to finish. We check various cases below in which
4786 * this can be turned off.
4787 */
4788 require_sleep = true;
4790 {
4791 /*
4792 * If we're requesting KeyShare, and there's no update present, we
4793 * don't need to wait. Even if there is an update, we can still
4794 * continue if the key hasn't been modified.
4795 *
4796 * However, if there are updates, we need to walk the update chain
4797 * to mark future versions of the row as locked, too. That way,
4798 * if somebody deletes that future version, we're protected
4799 * against the key going away. This locking of future versions
4800 * could block momentarily, if a concurrent transaction is
4801 * deleting a key; or it could return a value to the effect that
4802 * the transaction deleting the key has already committed. So we
4803 * do this before re-locking the buffer; otherwise this would be
4804 * prone to deadlocks.
4805 *
4806 * Note that the TID we're locking was grabbed before we unlocked
4807 * the buffer. For it to change while we're not looking, the
4808 * other properties we're testing for below after re-locking the
4809 * buffer would also change, in which case we would restart this
4810 * loop above.
4811 */
4813 {
4814 bool updated;
4815
4816 updated = !HEAP_XMAX_IS_LOCKED_ONLY(infomask);
4817
4818 /*
4819 * If there are updates, follow the update chain; bail out if
4820 * that cannot be done.
4821 */
4822 if (follow_updates && updated &&
4824 {
4825 TM_Result res;
4826
4827 res = heap_lock_updated_tuple(relation,
4828 infomask, xwait, &t_ctid,
4829 GetCurrentTransactionId(),
4830 mode);
4832 {
4833 result = res;
4834 /* recovery code expects to have buffer lock held */
4836 goto failed;
4837 }
4838 }
4839
4841
4842 /*
4843 * Make sure it's still an appropriate lock, else start over.
4844 * Also, if it wasn't updated before we released the lock, but
4845 * is updated now, we start over too; the reason is that we
4846 * now need to follow the update chain to lock the new
4847 * versions.
4848 */
4851 !updated))
4852 goto l3;
4853
4854 /* Things look okay, so we can skip sleeping */
4855 require_sleep = false;
4856
4857 /*
4858 * Note we allow Xmax to change here; other updaters/lockers
4859 * could have modified it before we grabbed the buffer lock.
4860 * However, this is not a problem, because with the recheck we
4861 * just did we ensure that they still don't conflict with the
4862 * lock we want.
4863 */
4864 }
4865 }
4867 {
4868 /*
4869 * If we're requesting Share, we can similarly avoid sleeping if
4870 * there's no update and no exclusive lock present.
4871 */
4873 !HEAP_XMAX_IS_EXCL_LOCKED(infomask))
4874 {
4876
4877 /*
4878 * Make sure it's still an appropriate lock, else start over.
4879 * See above about allowing xmax to change.
4880 */
4883 goto l3;
4884 require_sleep = false;
4885 }
4886 }
4888 {
4889 /*
4890 * If we're requesting NoKeyExclusive, we might also be able to
4891 * avoid sleeping; just ensure that there no conflicting lock
4892 * already acquired.
4893 */
4895 {
4897 mode, NULL))
4898 {
4899 /*
4900 * No conflict, but if the xmax changed under us in the
4901 * meantime, start over.
4902 */
4906 xwait))
4907 goto l3;
4908
4909 /* otherwise, we're good */
4910 require_sleep = false;
4911 }
4912 }
4914 {
4916
4917 /* if the xmax changed in the meantime, start over */
4920 xwait))
4921 goto l3;
4922 /* otherwise, we're good */
4923 require_sleep = false;
4924 }
4925 }
4926
4927 /*
4928 * As a check independent from those above, we can also avoid sleeping
4929 * if the current transaction is the sole locker of the tuple. Note
4930 * that the strength of the lock already held is irrelevant; this is
4931 * not about recording the lock in Xmax (which will be done regardless
4932 * of this optimization, below). Also, note that the cases where we
4933 * hold a lock stronger than we are requesting are already handled
4934 * above by not doing anything.
4935 *
4936 * Note we only deal with the non-multixact case here; MultiXactIdWait
4937 * is well equipped to deal with this situation on its own.
4938 */
4940 TransactionIdIsCurrentTransactionId(xwait))
4941 {
4942 /* ... but if the xmax changed in the meantime, start over */
4946 xwait))
4947 goto l3;
4949 require_sleep = false;
4950 }
4951
4952 /*
4953 * Time to sleep on the other transaction/multixact, if necessary.
4954 *
4955 * If the other transaction is an update/delete that's already
4956 * committed, then sleeping cannot possibly do any good: if we're
4957 * required to sleep, get out to raise an error instead.
4958 *
4959 * By here, we either have already acquired the buffer exclusive lock,
4960 * or we must wait for the locking transaction or multixact; so below
4961 * we ensure that we grab buffer lock after the sleep.
4962 */
4964 {
4966 goto failed;
4967 }
4968 else if (require_sleep)
4969 {
4970 /*
4971 * Acquire tuple lock to establish our priority for the tuple, or
4972 * die trying. LockTuple will release us when we are next-in-line
4973 * for the tuple. We must do this even if we are share-locking,
4974 * but not if we already have a weaker lock on the tuple.
4975 *
4976 * If we are forced to "start over" below, we keep the tuple lock;
4977 * this arranges that we stay at the head of the line while
4978 * rechecking tuple state.
4979 */
4980 if (!skip_tuple_lock &&
4982 &have_tuple_lock))
4983 {
4984 /*
4985 * This can only happen if wait_policy is Skip and the lock
4986 * couldn't be obtained.
4987 */
4988 result = TM_WouldBlock;
4989 /* recovery code expects to have buffer lock held */
4991 goto failed;
4992 }
4993
4995 {
4997
4998 /* We only ever lock tuples, never update them */
5001
5002 /* wait for multixact to end, or die trying */
5003 switch (wait_policy)
5004 {
5008 break;
5011 status, infomask, relation,
5012 NULL, false))
5013 {
5014 result = TM_WouldBlock;
5015 /* recovery code expects to have buffer lock held */
5017 goto failed;
5018 }
5019 break;
5022 status, infomask, relation,
5023 NULL, log_lock_failures))
5025 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
5027 RelationGetRelationName(relation))));
5028
5029 break;
5030 }
5031
5032 /*
5033 * Of course, the multixact might not be done here: if we're
5034 * requesting a light lock mode, other transactions with light
5035 * locks could still be alive, as well as locks owned by our
5036 * own xact or other subxacts of this backend. We need to
5037 * preserve the surviving MultiXact members. Note that it
5038 * isn't absolutely necessary in the latter case, but doing so
5039 * is simpler.
5040 */
5041 }
5042 else
5043 {
5044 /* wait for regular transaction to end, or die trying */
5045 switch (wait_policy)
5046 {
5049 XLTW_Lock);
5050 break;
5053 {
5054 result = TM_WouldBlock;
5055 /* recovery code expects to have buffer lock held */
5057 goto failed;
5058 }
5059 break;
5063 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
5065 RelationGetRelationName(relation))));
5066 break;
5067 }
5068 }
5069
5070 /* if there are updates, follow the update chain */
5073 {
5074 TM_Result res;
5075
5076 res = heap_lock_updated_tuple(relation,
5077 infomask, xwait, &t_ctid,
5078 GetCurrentTransactionId(),
5079 mode);
5081 {
5082 result = res;
5083 /* recovery code expects to have buffer lock held */
5085 goto failed;
5086 }
5087 }
5088
5090
5091 /*
5092 * xwait is done, but if xwait had just locked the tuple then some
5093 * other xact could update this tuple before we get to this point.
5094 * Check for xmax change, and start over if so.
5095 */
5098 xwait))
5099 goto l3;
5100
5102 {
5103 /*
5104 * Otherwise check if it committed or aborted. Note we cannot
5105 * be here if the tuple was only locked by somebody who didn't
5106 * conflict with us; that would have been handled above. So
5107 * that transaction must necessarily be gone by now. But
5108 * don't check for this in the multixact case, because some
5109 * locker transactions might still be running.
5110 */
5112 }
5113 }
5114
5115 /* By here, we're certain that we hold buffer exclusive lock again */
5116
5117 /*
5118 * We may lock if previous xmax aborted, or if it committed but only
5119 * locked the tuple without updating it; or if we didn't have to wait
5120 * at all for whatever reason.
5121 */
5122 if (!require_sleep ||
5126 result = TM_Ok;
5128 result = TM_Updated;
5129 else
5130 result = TM_Deleted;
5131 }
5132
5133failed:
5135 {
5138
5139 /*
5140 * When locking a tuple under LockWaitSkip semantics and we fail with
5141 * TM_WouldBlock above, it's possible for concurrent transactions to
5142 * release the lock and set HEAP_XMAX_INVALID in the meantime. So
5143 * this assert is slightly different from the equivalent one in
5144 * heap_delete and heap_update.
5145 */
5154 else
5156 goto out_locked;
5157 }
5158
5159 /*
5160 * If we didn't pin the visibility map page and the page has become all
5161 * visible while we were busy locking the buffer, or during some
5162 * subsequent window during which we had it unlocked, we'll have to unlock
5163 * and re-lock, to avoid holding the buffer lock across I/O. That's a bit
5164 * unfortunate, especially since we'll now have to recheck whether the
5165 * tuple has been locked or updated under us, but hopefully it won't
5166 * happen very often.
5167 */
5169 {
5171 visibilitymap_pin(relation, block, &vmbuffer);
5173 goto l3;
5174 }
5175
5178
5179 /*
5180 * If this is the first possibly-multixact-able operation in the current
5181 * transaction, set my per-backend OldestMemberMXactId setting. We can be
5182 * certain that the transaction will never become a member of any older
5183 * MultiXactIds than that. (We have to do this even if we end up just
5184 * using our own TransactionId below, since some other backend could
5185 * incorporate our XID into a MultiXact immediately afterwards.)
5186 */
5187 MultiXactIdSetOldestMember();
5188
5189 /*
5190 * Compute the new xmax and infomask to store into the tuple. Note we do
5191 * not modify the tuple just yet, because that would leave it in the wrong
5192 * state if multixact.c elogs.
5193 */
5196 &xid, &new_infomask, &new_infomask2);
5197
5198 START_CRIT_SECTION();
5199
5200 /*
5201 * Store transaction information of xact locking the tuple.
5202 *
5203 * Note: Cmax is meaningless in this context, so don't set it; this avoids
5204 * possibly generating a useless combo CID. Moreover, if we're locking a
5205 * previously updated tuple, it's important to preserve the Cmax.
5206 *
5207 * Also reset the HOT UPDATE bit, but only if there's no update; otherwise
5208 * we would break the HOT chain.
5209 */
5217
5218 /*
5219 * Make sure there is no forward chain link in t_ctid. Note that in the
5220 * cases where the tuple has been updated, we must not overwrite t_ctid,
5221 * because it was set by the updater. Moreover, if the tuple has been
5222 * updated, we need to follow the update chain to lock the new versions of
5223 * the tuple as well.
5224 */
5227
5228 /* Clear only the all-frozen bit on visibility map if needed */
5230 visibilitymap_clear(relation, block, vmbuffer,
5231 VISIBILITYMAP_ALL_FROZEN))
5232 cleared_all_frozen = true;
5233
5234
5235 MarkBufferDirty(*buffer);
5236
5237 /*
5238 * XLOG stuff. You might think that we don't need an XLOG record because
5239 * there is no state change worth restoring after a crash. You would be
5240 * wrong however: we have just written either a TransactionId or a
5241 * MultiXactId that may never have been seen on disk before, and we need
5242 * to make sure that there are XLOG entries covering those ID numbers.
5243 * Else the same IDs might be re-used after a crash, which would be
5244 * disastrous if this page made it to disk before the crash. Essentially
5245 * we have to enforce the WAL log-before-data rule even in this case.
5246 * (Also, in a PITR log-shipping or 2PC environment, we have to have XLOG
5247 * entries for everything anyway.)
5248 */
5250 {
5251 xl_heap_lock xlrec;
5252 XLogRecPtr recptr;
5253
5254 XLogBeginInsert();
5256
5258 xlrec.xmax = xid;
5263
5264 /* we don't decode row locks atm, so no need to log the origin */
5265
5267
5268 PageSetLSN(page, recptr);
5269 }
5270
5271 END_CRIT_SECTION();
5272
5273 result = TM_Ok;
5274
5275out_locked:
5277
5278out_unlocked:
5280 ReleaseBuffer(vmbuffer);
5281
5282 /*
5283 * Don't update the visibility map here. Locking a tuple doesn't change
5284 * visibility info.
5285 */
5286
5287 /*
5288 * Now that we have successfully marked the tuple as locked, we can
5289 * release the lmgr tuple lock, if we had it.
5290 */
5291 if (have_tuple_lock)
5293
5294 return result;
5295}
static bool ConditionalMultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, Relation rel, int *remaining, bool logLockFailure)
Definition: heapam.c:7840
static TM_Result heap_lock_updated_tuple(Relation rel, uint16 prior_infomask, TransactionId prior_raw_xmax, const ItemPointerData *prior_ctid, TransactionId xid, LockTupleMode mode)
Definition: heapam.c:6079
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 6079 of file heapam.c.
6084{
6086
6087 /*
6088 * If the tuple has moved into another partition (effectively a delete)
6089 * stop here.
6090 */
6092 {
6093 TransactionId prior_xmax;
6094
6095 /*
6096 * If this is the first possibly-multixact-able operation in the
6097 * current transaction, set my per-backend OldestMemberMXactId
6098 * setting. We can be certain that the transaction will never become a
6099 * member of any older MultiXactIds than that. (We have to do this
6100 * even if we end up just using our own TransactionId below, since
6101 * some other backend could incorporate our XID into a MultiXact
6102 * immediately afterwards.)
6103 */
6104 MultiXactIdSetOldestMember();
6105
6106 prior_xmax = (prior_infomask & HEAP_XMAX_IS_MULTI) ?
6107 MultiXactIdGetUpdateXid(prior_raw_xmax, prior_infomask) : prior_raw_xmax;
6109 }
6110
6111 /* nothing to lock */
6113}
static TM_Result heap_lock_updated_tuple_rec(Relation rel, TransactionId priorXmax, const ItemPointerData *tid, TransactionId xid, LockTupleMode mode)
Definition: heapam.c:5731
static bool ItemPointerIndicatesMovedPartitions(const ItemPointerData *pointer)
Definition: itemptr.h:197
References heap_lock_updated_tuple_rec(), HEAP_XMAX_IS_MULTI, INJECTION_POINT, ItemPointerIndicatesMovedPartitions(), mode, MultiXactIdGetUpdateXid(), MultiXactIdSetOldestMember(), and TM_Ok.
Referenced by heap_lock_tuple().
◆ heap_lock_updated_tuple_rec()
|
static |
Definition at line 5731 of file heapam.c.
5734{
5735 TM_Result result;
5736 ItemPointerData tupid;
5737 HeapTupleData mytup;
5739 uint16 new_infomask,
5740 new_infomask2,
5741 old_infomask,
5742 old_infomask2;
5743 TransactionId xmax,
5744 new_xmax;
5745 bool cleared_all_frozen = false;
5746 bool pinned_desired_page;
5748 BlockNumber block;
5749
5750 ItemPointerCopy(tid, &tupid);
5751
5752 for (;;)
5753 {
5754 new_infomask = 0;
5755 new_xmax = InvalidTransactionId;
5756 block = ItemPointerGetBlockNumber(&tupid);
5758
5760 {
5761 /*
5762 * if we fail to find the updated version of the tuple, it's
5763 * because it was vacuumed/pruned away after its creator
5764 * transaction aborted. So behave as if we got to the end of the
5765 * chain, and there's no further tuple to lock: return success to
5766 * caller.
5767 */
5768 result = TM_Ok;
5769 goto out_unlocked;
5770 }
5771
5772l4:
5773 CHECK_FOR_INTERRUPTS();
5774
5775 /*
5776 * Before locking the buffer, pin the visibility map page if it
5777 * appears to be necessary. Since we haven't got the lock yet,
5778 * someone else might be in the middle of changing this, so we'll need
5779 * to recheck after we have the lock.
5780 */
5782 {
5783 visibilitymap_pin(rel, block, &vmbuffer);
5784 pinned_desired_page = true;
5785 }
5786 else
5787 pinned_desired_page = false;
5788
5790
5791 /*
5792 * If we didn't pin the visibility map page and the page has become
5793 * all visible while we were busy locking the buffer, we'll have to
5794 * unlock and re-lock, to avoid holding the buffer lock across I/O.
5795 * That's a bit unfortunate, but hopefully shouldn't happen often.
5796 *
5797 * Note: in some paths through this function, we will reach here
5798 * holding a pin on a vm page that may or may not be the one matching
5799 * this page. If this page isn't all-visible, we won't use the vm
5800 * page, but we hold onto such a pin till the end of the function.
5801 */
5803 {
5805 visibilitymap_pin(rel, block, &vmbuffer);
5807 }
5808
5809 /*
5810 * Check the tuple XMIN against prior XMAX, if any. If we reached the
5811 * end of the chain, we're done, so return success.
5812 */
5815 priorXmax))
5816 {
5817 result = TM_Ok;
5818 goto out_locked;
5819 }
5820
5821 /*
5822 * Also check Xmin: if this tuple was created by an aborted
5823 * (sub)transaction, then we already locked the last live one in the
5824 * chain, thus we're done, so return success.
5825 */
5827 {
5828 result = TM_Ok;
5829 goto out_locked;
5830 }
5831
5835
5836 /*
5837 * If this tuple version has been updated or locked by some concurrent
5838 * transaction(s), what we do depends on whether our lock mode
5839 * conflicts with what those other transactions hold, and also on the
5840 * status of them.
5841 */
5843 {
5844 TransactionId rawxmax;
5845 bool needwait;
5846
5849 {
5850 int nmembers;
5852 MultiXactMember *members;
5853
5854 /*
5855 * We don't need a test for pg_upgrade'd tuples: this is only
5856 * applied to tuples after the first in an update chain. Said
5857 * first tuple in the chain may well be locked-in-9.2-and-
5858 * pg_upgraded, but that one was already locked by our caller,
5859 * not us; and any subsequent ones cannot be because our
5860 * caller must necessarily have obtained a snapshot later than
5861 * the pg_upgrade itself.
5862 */
5864
5866 HEAP_XMAX_IS_LOCKED_ONLY(old_infomask));
5868 {
5870 members[i].xid,
5871 mode,
5872 &mytup,
5873 &needwait);
5874
5875 /*
5876 * If the tuple was already locked by ourselves in a
5877 * previous iteration of this (say heap_lock_tuple was
5878 * forced to restart the locking loop because of a change
5879 * in xmax), then we hold the lock already on this tuple
5880 * version and we don't need to do anything; and this is
5881 * not an error condition either. We just need to skip
5882 * this tuple and continue locking the next version in the
5883 * update chain.
5884 */
5886 {
5887 pfree(members);
5889 }
5890
5891 if (needwait)
5892 {
5895 &mytup.t_self,
5896 XLTW_LockUpdated);
5897 pfree(members);
5898 goto l4;
5899 }
5901 {
5902 pfree(members);
5903 goto out_locked;
5904 }
5905 }
5906 if (members)
5907 pfree(members);
5908 }
5909 else
5910 {
5911 MultiXactStatus status;
5912
5913 /*
5914 * For a non-multi Xmax, we first need to compute the
5915 * corresponding MultiXactStatus by using the infomask bits.
5916 */
5918 {
5920 status = MultiXactStatusForKeyShare;
5922 status = MultiXactStatusForShare;
5924 {
5926 status = MultiXactStatusForUpdate;
5927 else
5928 status = MultiXactStatusForNoKeyUpdate;
5929 }
5930 else
5931 {
5932 /*
5933 * LOCK_ONLY present alone (a pg_upgraded tuple marked
5934 * as share-locked in the old cluster) shouldn't be
5935 * seen in the middle of an update chain.
5936 */
5938 }
5939 }
5940 else
5941 {
5942 /* it's an update, but which kind? */
5944 status = MultiXactStatusUpdate;
5945 else
5946 status = MultiXactStatusNoKeyUpdate;
5947 }
5948
5950 &mytup, &needwait);
5951
5952 /*
5953 * If the tuple was already locked by ourselves in a previous
5954 * iteration of this (say heap_lock_tuple was forced to
5955 * restart the locking loop because of a change in xmax), then
5956 * we hold the lock already on this tuple version and we don't
5957 * need to do anything; and this is not an error condition
5958 * either. We just need to skip this tuple and continue
5959 * locking the next version in the update chain.
5960 */
5963
5964 if (needwait)
5965 {
5968 XLTW_LockUpdated);
5969 goto l4;
5970 }
5972 {
5973 goto out_locked;
5974 }
5975 }
5976 }
5977
5978 /* compute the new Xmax and infomask values for the tuple ... */
5981 &new_xmax, &new_infomask, &new_infomask2);
5982
5984 visibilitymap_clear(rel, block, vmbuffer,
5985 VISIBILITYMAP_ALL_FROZEN))
5986 cleared_all_frozen = true;
5987
5988 START_CRIT_SECTION();
5989
5990 /* ... and set them */
5996
5998
5999 /* XLOG stuff */
6001 {
6002 xl_heap_lock_updated xlrec;
6003 XLogRecPtr recptr;
6005
6006 XLogBeginInsert();
6008
6010 xlrec.xmax = new_xmax;
6012 xlrec.flags =
6013 cleared_all_frozen ? XLH_LOCK_ALL_FROZEN_CLEARED : 0;
6014
6016
6018
6019 PageSetLSN(page, recptr);
6020 }
6021
6022 END_CRIT_SECTION();
6023
6024next:
6025 /* if we find the end of update chain, we're done. */
6030 {
6031 result = TM_Ok;
6032 goto out_locked;
6033 }
6034
6035 /* tail recursion */
6039 }
6040
6041 result = TM_Ok;
6042
6043out_locked:
6045
6046out_unlocked:
6048 ReleaseBuffer(vmbuffer);
6049
6050 return result;
6051}
bool heap_fetch(Relation relation, Snapshot snapshot, HeapTuple tuple, Buffer *userbuf, bool keep_buf)
Definition: heapam.c:1623
static TM_Result test_lockmode_for_conflict(MultiXactStatus status, TransactionId xid, LockTupleMode mode, HeapTuple tup, bool *needwait)
Definition: heapam.c:5640
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 2377 of file heapam.c.
2379{
2381 HeapTuple *heaptuples;
2383 int ndone;
2384 PGAlignedBlock scratch;
2385 Page page;
2387 bool needwal;
2388 Size saveFreeSpace;
2391 bool starting_with_empty_page = false;
2392 int npages = 0;
2393 int npages_used = 0;
2394
2395 /* currently not needed (thus unsupported) for heap_multi_insert() */
2397
2398 AssertHasSnapshotForToast(relation);
2399
2400 needwal = RelationNeedsWAL(relation);
2401 saveFreeSpace = RelationGetTargetPageFreeSpace(relation,
2402 HEAP_DEFAULT_FILLFACTOR);
2403
2404 /* Toast and set header data in all the slots */
2407 {
2408 HeapTuple tuple;
2409
2414 options);
2415 }
2416
2417 /*
2418 * We're about to do the actual inserts -- but check for conflict first,
2419 * to minimize the possibility of having to roll back work we've just
2420 * done.
2421 *
2422 * A check here does not definitively prevent a serialization anomaly;
2423 * that check MUST be done at least past the point of acquiring an
2424 * exclusive buffer content lock on every buffer that will be affected,
2425 * and MAY be done after all inserts are reflected in the buffers and
2426 * those locks are released; otherwise there is a race condition. Since
2427 * multiple buffers can be locked and unlocked in the loop below, and it
2428 * would not be feasible to identify and lock all of those buffers before
2429 * the loop, we must do a final check at the end.
2430 *
2431 * The check here could be omitted with no loss of correctness; it is
2432 * present strictly as an optimization.
2433 *
2434 * For heap inserts, we only need to check for table-level SSI locks. Our
2435 * new tuples can't possibly conflict with existing tuple locks, and heap
2436 * page locks are only consolidated versions of tuple locks; they do not
2437 * lock "gaps" as index page locks do. So we don't need to specify a
2438 * buffer when making the call, which makes for a faster check.
2439 */
2441
2442 ndone = 0;
2443 while (ndone < ntuples)
2444 {
2445 Buffer buffer;
2446 bool all_visible_cleared = false;
2447 bool all_frozen_set = false;
2448 int nthispage;
2449
2450 CHECK_FOR_INTERRUPTS();
2451
2452 /*
2453 * Compute number of pages needed to fit the to-be-inserted tuples in
2454 * the worst case. This will be used to determine how much to extend
2455 * the relation by in RelationGetBufferForTuple(), if needed. If we
2456 * filled a prior page from scratch, we can just update our last
2457 * computation, but if we started with a partially filled page,
2458 * recompute from scratch, the number of potentially required pages
2459 * can vary due to tuples needing to fit onto the page, page headers
2460 * etc.
2461 */
2462 if (ndone == 0 || !starting_with_empty_page)
2463 {
2464 npages = heap_multi_insert_pages(heaptuples, ndone, ntuples,
2465 saveFreeSpace);
2466 npages_used = 0;
2467 }
2468 else
2469 npages_used++;
2470
2471 /*
2472 * Find buffer where at least the next tuple will fit. If the page is
2473 * all-visible, this will also pin the requisite visibility map page.
2474 *
2475 * Also pin visibility map page if COPY FREEZE inserts tuples into an
2476 * empty page. See all_frozen_set below.
2477 */
2478 buffer = RelationGetBufferForTuple(relation, heaptuples[ndone]->t_len,
2480 &vmbuffer, NULL,
2481 npages - npages_used);
2482 page = BufferGetPage(buffer);
2483
2484 starting_with_empty_page = PageGetMaxOffsetNumber(page) == 0;
2485
2487 {
2488 all_frozen_set = true;
2489 /* Lock the vmbuffer before entering the critical section */
2491 }
2492
2493 /* NO EREPORT(ERROR) from here till changes are logged */
2494 START_CRIT_SECTION();
2495
2496 /*
2497 * RelationGetBufferForTuple has ensured that the first tuple fits.
2498 * Put that on the page, and then as many other tuples as fit.
2499 */
2501
2502 /*
2503 * For logical decoding we need combo CIDs to properly decode the
2504 * catalog.
2505 */
2506 if (needwal && need_cids)
2507 log_heap_new_cid(relation, heaptuples[ndone]);
2508
2509 for (nthispage = 1; ndone + nthispage < ntuples; nthispage++)
2510 {
2511 HeapTuple heaptup = heaptuples[ndone + nthispage];
2512
2514 break;
2515
2517
2518 /*
2519 * For logical decoding we need combo CIDs to properly decode the
2520 * catalog.
2521 */
2522 if (needwal && need_cids)
2523 log_heap_new_cid(relation, heaptup);
2524 }
2525
2526 /*
2527 * If the page is all visible, need to clear that, unless we're only
2528 * going to add further frozen rows to it.
2529 *
2530 * If we're only adding already frozen rows to a previously empty
2531 * page, mark it as all-frozen and update the visibility map. We're
2532 * already holding a pin on the vmbuffer.
2533 */
2535 {
2536 all_visible_cleared = true;
2537 PageClearAllVisible(page);
2538 visibilitymap_clear(relation,
2539 BufferGetBlockNumber(buffer),
2540 vmbuffer, VISIBILITYMAP_VALID_BITS);
2541 }
2542 else if (all_frozen_set)
2543 {
2544 PageSetAllVisible(page);
2546 vmbuffer,
2547 VISIBILITYMAP_ALL_VISIBLE |
2548 VISIBILITYMAP_ALL_FROZEN,
2549 relation->rd_locator);
2550 }
2551
2552 /*
2553 * XXX Should we set PageSetPrunable on this page ? See heap_insert()
2554 */
2555
2556 MarkBufferDirty(buffer);
2557
2558 /* XLOG stuff */
2559 if (needwal)
2560 {
2561 XLogRecPtr recptr;
2562 xl_heap_multi_insert *xlrec;
2564 char *tupledata;
2565 int totaldatalen;
2568 int bufflags = 0;
2569
2570 /*
2571 * If the page was previously empty, we can reinit the page
2572 * instead of restoring the whole thing.
2573 */
2574 init = starting_with_empty_page;
2575
2576 /* allocate xl_heap_multi_insert struct from the scratch area */
2577 xlrec = (xl_heap_multi_insert *) scratchptr;
2578 scratchptr += SizeOfHeapMultiInsert;
2579
2580 /*
2581 * Allocate offsets array. Unless we're reinitializing the page,
2582 * in that case the tuples are stored in order starting at
2583 * FirstOffsetNumber and we don't need to store the offsets
2584 * explicitly.
2585 */
2588
2589 /* the rest of the scratch space is used for tuple data */
2590 tupledata = scratchptr;
2591
2592 /* check that the mutually exclusive flags are not both set */
2593 Assert(!(all_visible_cleared && all_frozen_set));
2594
2595 xlrec->flags = 0;
2596 if (all_visible_cleared)
2598
2599 /*
2600 * We don't have to worry about including a conflict xid in the
2601 * WAL record, as HEAP_INSERT_FROZEN intentionally violates
2602 * visibility rules.
2603 */
2604 if (all_frozen_set)
2606
2607 xlrec->ntuples = nthispage;
2608
2609 /*
2610 * Write out an xl_multi_insert_tuple and the tuple data itself
2611 * for each tuple.
2612 */
2614 {
2616 xl_multi_insert_tuple *tuphdr;
2617 int datalen;
2618
2621 /* xl_multi_insert_tuple needs two-byte alignment. */
2624
2628
2629 /* write bitmap [+ padding] [+ oid] + data */
2631 memcpy(scratchptr,
2633 datalen);
2634 tuphdr->datalen = datalen;
2635 scratchptr += datalen;
2636 }
2637 totaldatalen = scratchptr - tupledata;
2639
2640 if (need_tuple_data)
2642
2643 /*
2644 * Signal that this is the last xl_heap_multi_insert record
2645 * emitted by this call to heap_multi_insert(). Needed for logical
2646 * decoding so it knows when to cleanup temporary data.
2647 */
2648 if (ndone + nthispage == ntuples)
2650
2652 {
2653 info |= XLOG_HEAP_INIT_PAGE;
2654 bufflags |= REGBUF_WILL_INIT;
2655 }
2656
2657 /*
2658 * If we're doing logical decoding, include the new tuple data
2659 * even if we take a full-page image of the page.
2660 */
2661 if (need_tuple_data)
2662 bufflags |= REGBUF_KEEP_DATA;
2663
2664 XLogBeginInsert();
2667 if (all_frozen_set)
2668 XLogRegisterBuffer(1, vmbuffer, 0);
2669
2670 XLogRegisterBufData(0, tupledata, totaldatalen);
2671
2672 /* filtering by origin on a row level is much more efficient */
2674
2675 recptr = XLogInsert(RM_HEAP2_ID, info);
2676
2677 PageSetLSN(page, recptr);
2678 if (all_frozen_set)
2679 {
2682 }
2683 }
2684
2685 END_CRIT_SECTION();
2686
2687 if (all_frozen_set)
2689
2690 UnlockReleaseBuffer(buffer);
2691 ndone += nthispage;
2692
2693 /*
2694 * NB: Only release vmbuffer after inserting all tuples - it's fairly
2695 * likely that we'll insert into subsequent heap pages that are likely
2696 * to use the same vm page.
2697 */
2698 }
2699
2700 /* We're done with inserting all tuples, so release the last vmbuffer. */
2702 ReleaseBuffer(vmbuffer);
2703
2704 /*
2705 * We're done with the actual inserts. Check for conflicts again, to
2706 * ensure that all rw-conflicts in to these inserts are detected. Without
2707 * this final check, a sequential scan of the heap may have locked the
2708 * table after the "before" check, missing one opportunity to detect the
2709 * conflict, and then scanned the table before the new tuples were there,
2710 * missing the other chance to detect the conflict.
2711 *
2712 * For heap inserts, we only need to check for table-level SSI locks. Our
2713 * new tuples can't possibly conflict with existing tuple locks, and heap
2714 * page locks are only consolidated versions of tuple locks; they do not
2715 * lock "gaps" as index page locks do. So we don't need to specify a
2716 * buffer when making the call.
2717 */
2719
2720 /*
2721 * If tuples are cacheable, mark them for invalidation from the caches in
2722 * case we abort. Note it is OK to do this after releasing the buffer,
2723 * because the heaptuples data structure is all in local memory, not in
2724 * the shared buffer.
2725 */
2727 {
2730 }
2731
2732 /* copy t_self fields back to the caller's slots */
2735
2736 pgstat_count_heap_insert(relation, ntuples);
2737}
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:2345
#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 2345 of file heapam.c.
2346{
2348 int npages = 1;
2349
2351 {
2353
2354 if (page_avail < tup_sz)
2355 {
2356 npages++;
2357 page_avail = BLCKSZ - SizeOfPageHeaderData - saveFreeSpace;
2358 }
2359 page_avail -= tup_sz;
2360 }
2361
2362 return npages;
2363}
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 7372 of file heapam.c.
7374{
7376
7378 {
7381 HeapTupleHeader htup;
7382
7384
7385 /* Deliberately avoid relying on tuple hint bits here */
7387 {
7389
7395 xmin)));
7396 }
7397
7398 /*
7399 * TransactionIdDidAbort won't work reliably in the presence of XIDs
7400 * left behind by transactions that were in progress during a crash,
7401 * so we can only check that xmax didn't commit
7402 */
7404 {
7406
7412 xmax)));
7413 }
7414 }
7415}
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 7099 of file heapam.c.
7103{
7104 bool xmin_already_frozen = false,
7105 xmax_already_frozen = false;
7106 bool freeze_xmin = false,
7107 replace_xvac = false,
7108 replace_xmax = false,
7109 freeze_xmax = false;
7110 TransactionId xid;
7111
7115 frz->frzflags = 0;
7116 frz->checkflags = 0;
7117
7118 /*
7119 * Process xmin, while keeping track of whether it's already frozen, or
7120 * will become frozen iff our freeze plan is executed by caller (could be
7121 * neither).
7122 */
7123 xid = HeapTupleHeaderGetXmin(tuple);
7125 xmin_already_frozen = true;
7126 else
7127 {
7132 xid, cutoffs->relfrozenxid)));
7133
7134 /* Will set freeze_xmin flags in freeze plan below */
7136
7137 /* Verify that xmin committed if and when freeze plan is executed */
7138 if (freeze_xmin)
7140 }
7141
7142 /*
7143 * Old-style VACUUM FULL is gone, but we have to process xvac for as long
7144 * as we support having MOVED_OFF/MOVED_IN tuples in the database
7145 */
7146 xid = HeapTupleHeaderGetXvac(tuple);
7148 {
7151
7152 /*
7153 * For Xvac, we always freeze proactively. This allows totally_frozen
7154 * tracking to ignore xvac.
7155 */
7157
7158 /* Will set replace_xvac flags in freeze plan below */
7159 }
7160
7161 /* Now process xmax */
7162 xid = frz->xmax;
7164 {
7165 /* Raw xmax is a MultiXactId */
7166 TransactionId newxmax;
7167 uint16 flags;
7168
7169 /*
7170 * We will either remove xmax completely (in the "freeze_xmax" path),
7171 * process xmax by replacing it (in the "replace_xmax" path), or
7172 * perform no-op xmax processing. The only constraint is that the
7173 * FreezeLimit/MultiXactCutoff postcondition must never be violated.
7174 */
7176 &flags, pagefrz);
7177
7179 {
7180 /*
7181 * xmax is a MultiXactId, and nothing about it changes for now.
7182 * This is the only case where 'freeze_required' won't have been
7183 * set for us by FreezeMultiXactId, as well as the only case where
7184 * neither freeze_xmax nor replace_xmax are set (given a multi).
7185 *
7186 * This is a no-op, but the call to FreezeMultiXactId might have
7187 * ratcheted back NewRelfrozenXid and/or NewRelminMxid trackers
7188 * for us (the "freeze page" variants, specifically). That'll
7189 * make it safe for our caller to freeze the page later on, while
7190 * leaving this particular xmax undisturbed.
7191 *
7192 * FreezeMultiXactId is _not_ responsible for the "no freeze"
7193 * NewRelfrozenXid/NewRelminMxid trackers, though -- that's our
7194 * job. A call to heap_tuple_should_freeze for this same tuple
7195 * will take place below if 'freeze_required' isn't set already.
7196 * (This repeats work from FreezeMultiXactId, but allows "no
7197 * freeze" tracker maintenance to happen in only one place.)
7198 */
7201 }
7203 {
7204 /*
7205 * xmax will become an updater Xid (original MultiXact's updater
7206 * member Xid will be carried forward as a simple Xid in Xmax).
7207 */
7209
7210 /*
7211 * NB -- some of these transformations are only valid because we
7212 * know the return Xid is a tuple updater (i.e. not merely a
7213 * locker.) Also note that the only reason we don't explicitly
7214 * worry about HEAP_KEYS_UPDATED is because it lives in
7215 * t_infomask2 rather than t_infomask.
7216 */
7217 frz->t_infomask &= ~HEAP_XMAX_BITS;
7218 frz->xmax = newxmax;
7221 replace_xmax = true;
7222 }
7224 {
7225 uint16 newbits;
7226 uint16 newbits2;
7227
7228 /*
7229 * xmax is an old MultiXactId that we have to replace with a new
7230 * MultiXactId, to carry forward two or more original member XIDs.
7231 */
7233
7234 /*
7235 * We can't use GetMultiXactIdHintBits directly on the new multi
7236 * here; that routine initializes the masks to all zeroes, which
7237 * would lose other bits we need. Doing it this way ensures all
7238 * unrelated bits remain untouched.
7239 */
7240 frz->t_infomask &= ~HEAP_XMAX_BITS;
7241 frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
7242 GetMultiXactIdHintBits(newxmax, &newbits, &newbits2);
7243 frz->t_infomask |= newbits;
7244 frz->t_infomask2 |= newbits2;
7245 frz->xmax = newxmax;
7246 replace_xmax = true;
7247 }
7248 else
7249 {
7250 /*
7251 * Freeze plan for tuple "freezes xmax" in the strictest sense:
7252 * it'll leave nothing in xmax (neither an Xid nor a MultiXactId).
7253 */
7256
7257 /* Will set freeze_xmax flags in freeze plan below */
7258 freeze_xmax = true;
7259 }
7260
7261 /* MultiXactId processing forces freezing (barring FRM_NOOP case) */
7263 }
7265 {
7266 /* Raw xmax is normal XID */
7271 xid, cutoffs->relfrozenxid)));
7272
7273 /* Will set freeze_xmax flags in freeze plan below */
7275
7276 /*
7277 * Verify that xmax aborted if and when freeze plan is executed,
7278 * provided it's from an update. (A lock-only xmax can be removed
7279 * independent of this, since the lock is released at xact end.)
7280 */
7283 }
7285 {
7286 /* Raw xmax is InvalidTransactionId XID */
7288 xmax_already_frozen = true;
7289 }
7290 else
7294 xid, tuple->t_infomask)));
7295
7296 if (freeze_xmin)
7297 {
7298 Assert(!xmin_already_frozen);
7299
7301 }
7302 if (replace_xvac)
7303 {
7304 /*
7305 * If a MOVED_OFF tuple is not dead, the xvac transaction must have
7306 * failed; whereas a non-dead MOVED_IN tuple must mean the xvac
7307 * transaction succeeded.
7308 */
7312 else
7314 }
7315 if (replace_xmax)
7316 {
7317 Assert(!xmax_already_frozen && !freeze_xmax);
7319
7320 /* Already set replace_xmax flags in freeze plan earlier */
7321 }
7322 if (freeze_xmax)
7323 {
7324 Assert(!xmax_already_frozen && !replace_xmax);
7325
7327
7328 /*
7329 * The tuple might be marked either XMAX_INVALID or XMAX_COMMITTED +
7330 * LOCKED. Normalize to INVALID just to be sure no one gets confused.
7331 * Also get rid of the HEAP_KEYS_UPDATED bit.
7332 */
7333 frz->t_infomask &= ~HEAP_XMAX_BITS;
7335 frz->t_infomask2 &= ~HEAP_HOT_UPDATED;
7336 frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
7337 }
7338
7339 /*
7340 * Determine if this tuple is already totally frozen, or will become
7341 * totally frozen (provided caller executes freeze plans for the page)
7342 */
7343 *totally_frozen = ((freeze_xmin || xmin_already_frozen) &&
7344 (freeze_xmax || xmax_already_frozen));
7345
7347 xmax_already_frozen))
7348 {
7349 /*
7350 * So far no previous tuple from the page made freezing mandatory.
7351 * Does this tuple force caller to freeze the entire page?
7352 */
7353 pagefrz->freeze_required =
7354 heap_tuple_should_freeze(tuple, cutoffs,
7355 &pagefrz->NoFreezePageRelfrozenXid,
7356 &pagefrz->NoFreezePageRelminMxid);
7357 }
7358
7359 /* Tell caller if this tuple has a usable freeze plan set in *frz */
7360 return freeze_xmin || replace_xvac || replace_xmax || freeze_xmax;
7361}
static TransactionId FreezeMultiXactId(MultiXactId multi, uint16 t_infomask, const struct VacuumCutoffs *cutoffs, uint16 *flags, HeapPageFreeze *pagefrz)
Definition: heapam.c:6749
bool heap_tuple_should_freeze(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, TransactionId *NoFreezePageRelfrozenXid, MultiXactId *NoFreezePageRelminMxid)
Definition: heapam.c:7910
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 2297 of file heapam.c.
2299{
2300 /*
2301 * To allow parallel inserts, we need to ensure that they are safe to be
2302 * performed in workers. We have the infrastructure to allow parallel
2303 * inserts in general except for the cases where inserts generate a new
2304 * CommandId (eg. inserts into a table having a foreign key column).
2305 */
2308 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
2310
2317
2321
2322 /*
2323 * If the new tuple is too big for storage or contains already toasted
2324 * out-of-line attributes from some other relation, invoke the toaster.
2325 */
2327 relation->rd_rel->relkind != RELKIND_MATVIEW)
2328 {
2329 /* toast table entries should never be recursively toasted */
2331 return tup;
2332 }
2335 else
2336 return tup;
2337}
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 570 of file heapam.c.
571{
575 Snapshot snapshot;
576 Page page;
577 int lines;
578 bool all_visible;
579 bool check_serializable;
580
582
583 /* ensure we're not accidentally being used when not in pagemode */
586
587 /*
588 * Prune and repair fragmentation for the whole page, if possible.
589 */
591
592 /*
593 * We must hold share lock on the buffer content while examining tuple
594 * visibility. Afterwards, however, the tuples we have found to be
595 * visible are guaranteed good as long as we hold the buffer pin.
596 */
598
599 page = BufferGetPage(buffer);
600 lines = PageGetMaxOffsetNumber(page);
601
602 /*
603 * If the all-visible flag indicates that all tuples on the page are
604 * visible to everyone, we can skip the per-tuple visibility tests.
605 *
606 * Note: In hot standby, a tuple that's already visible to all
607 * transactions on the primary might still be invisible to a read-only
608 * transaction in the standby. We partly handle this problem by tracking
609 * the minimum xmin of visible tuples as the cut-off XID while marking a
610 * page all-visible on the primary and WAL log that along with the
611 * visibility map SET operation. In hot standby, we wait for (or abort)
612 * all transactions that can potentially may not see one or more tuples on
613 * the page. That's how index-only scans work fine in hot standby. A
614 * crucial difference between index-only scans and heap scans is that the
615 * index-only scan completely relies on the visibility map where as heap
616 * scan looks at the page-level PD_ALL_VISIBLE flag. We are not sure if
617 * the page-level flag can be trusted in the same way, because it might
618 * get propagated somehow without being explicitly WAL-logged, e.g. via a
619 * full page write. Until we can prove that beyond doubt, let's check each
620 * tuple for visibility the hard way.
621 */
623 check_serializable =
625
626 /*
627 * We call page_collect_tuples() with constant arguments, to get the
628 * compiler to constant fold the constant arguments. Separate calls with
629 * constant arguments, rather than variables, are needed on several
630 * compilers to actually perform constant folding.
631 */
633 {
636 block, lines, true, false);
637 else
639 block, lines, true, true);
640 }
641 else
642 {
645 block, lines, false, false);
646 else
648 block, lines, false, true);
649 }
650
652}
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:520
bool CheckForSerializableConflictOutNeeded(Relation relation, Snapshot snapshot)
Definition: predicate.c:3989
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 1272 of file heapam.c.
1274{
1276
1277 if (set_params)
1278 {
1279 if (allow_strat)
1281 else
1283
1284 if (allow_sync)
1286 else
1288
1292 else
1294 }
1295
1296 /*
1297 * unpin scan buffers
1298 */
1300 {
1303 }
1304
1305 /*
1306 * SO_TYPE_BITMAPSCAN would be cleaned up here, but it does not hold any
1307 * additional data vs a normal HeapScan
1308 */
1309
1310 /*
1311 * The read stream is reset on rescan. This must be done before
1312 * initscan(), as some state referred to by read_stream_reset() is reset
1313 * in initscan().
1314 */
1317
1318 /*
1319 * reinitialize scan descriptor
1320 */
1322}
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 250 of file heapam.c.
253{
255
258
260 {
261 /* parallel scan */
263 scan->rs_parallelworkerdata,
265 scan->rs_startblock,
266 scan->rs_numblocks);
267
268 /* may return InvalidBlockNumber if there are no more blocks */
270 scan->rs_parallelworkerdata,
273 }
274 else
275 {
279 }
280
282}
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 290 of file heapam.c.
293{
295
297 {
300 }
301 else
303 scan->rs_prefetch_block,
304 scan->rs_dir);
305
307}
static pg_noinline BlockNumber heapgettup_initial_block(HeapScanDesc scan, ScanDirection dir)
Definition: heapam.c:706
static BlockNumber heapgettup_advance_block(HeapScanDesc scan, BlockNumber block, ScanDirection dir)
Definition: heapam.c:830
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 1443 of file heapam.c.
1445{
1447 BlockNumber startBlk;
1448 BlockNumber numBlks;
1449 ItemPointerData highestItem;
1450 ItemPointerData lowestItem;
1451
1452 /*
1453 * For relations without any pages, we can simply leave the TID range
1454 * unset. There will be no tuples to scan, therefore no tuples outside
1455 * the given TID range.
1456 */
1458 return;
1459
1460 /*
1461 * Set up some ItemPointers which point to the first and last possible
1462 * tuples in the heap.
1463 */
1466
1467 /*
1468 * If the given maximum TID is below the highest possible TID in the
1469 * relation, then restrict the range to that, otherwise we scan to the end
1470 * of the relation.
1471 */
1473 ItemPointerCopy(maxtid, &highestItem);
1474
1475 /*
1476 * If the given minimum TID is above the lowest possible TID in the
1477 * relation, then restrict the range to only scan for TIDs above that.
1478 */
1480 ItemPointerCopy(mintid, &lowestItem);
1481
1482 /*
1483 * Check for an empty range and protect from would be negative results
1484 * from the numBlks calculation below.
1485 */
1487 {
1488 /* Set an empty range of blocks to scan */
1489 heap_setscanlimits(sscan, 0, 0);
1490 return;
1491 }
1492
1493 /*
1494 * Calculate the first block and the number of blocks we must scan. We
1495 * could be more aggressive here and perform some more validation to try
1496 * and further narrow the scope of blocks to scan by checking if the
1497 * lowestItem has an offset above MaxOffsetNumber. In this case, we could
1498 * advance startBlk by one. Likewise, if highestItem has an offset of 0
1499 * we could scan one fewer blocks. However, such an optimization does not
1500 * seem worth troubling over, currently.
1501 */
1502 startBlk = ItemPointerGetBlockNumberNoCheck(&lowestItem);
1503
1504 numBlks = ItemPointerGetBlockNumberNoCheck(&highestItem) -
1505 ItemPointerGetBlockNumberNoCheck(&lowestItem) + 1;
1506
1507 /* Set the start block and number of blocks to scan */
1508 heap_setscanlimits(sscan, startBlk, numBlks);
1509
1510 /* Finally, set the TID range in sscan */
1513}
void heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks)
Definition: heapam.c:498
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 498 of file heapam.c.
499{
501
503 /* else rs_startblock is significant */
505
506 /* Check startBlk is valid (but allow case of zero blocks...) */
507 Assert(startBlk == 0 || startBlk < scan->rs_nblocks);
508
509 scan->rs_startblock = startBlk;
510 scan->rs_numblocks = numBlks;
511}
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 7855 of file heapam.c.
7856{
7857 TransactionId xid;
7858
7859 /*
7860 * If xmin is a normal transaction ID, this tuple is definitely not
7861 * frozen.
7862 */
7863 xid = HeapTupleHeaderGetXmin(tuple);
7865 return true;
7866
7867 /*
7868 * If xmax is a valid xact or multixact, this tuple is also not frozen.
7869 */
7871 {
7872 MultiXactId multi;
7873
7874 multi = HeapTupleHeaderGetRawXmax(tuple);
7876 return true;
7877 }
7878 else
7879 {
7880 xid = HeapTupleHeaderGetRawXmax(tuple);
7882 return true;
7883 }
7884
7886 {
7887 xid = HeapTupleHeaderGetXvac(tuple);
7889 return true;
7890 }
7891
7892 return false;
7893}
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 7910 of file heapam.c.
7914{
7915 TransactionId xid;
7916 MultiXactId multi;
7917 bool freeze = false;
7918
7919 /* First deal with xmin */
7920 xid = HeapTupleHeaderGetXmin(tuple);
7922 {
7925 *NoFreezePageRelfrozenXid = xid;
7927 freeze = true;
7928 }
7929
7930 /* Now deal with xmax */
7931 xid = InvalidTransactionId;
7932 multi = InvalidMultiXactId;
7934 multi = HeapTupleHeaderGetRawXmax(tuple);
7935 else
7936 xid = HeapTupleHeaderGetRawXmax(tuple);
7937
7939 {
7941 /* xmax is a non-permanent XID */
7943 *NoFreezePageRelfrozenXid = xid;
7945 freeze = true;
7946 }
7948 {
7949 /* xmax is a permanent XID or invalid MultiXactId/XID */
7950 }
7952 {
7953 /* xmax is a pg_upgrade'd MultiXact, which can't have updater XID */
7955 *NoFreezePageRelminMxid = multi;
7956 /* heap_prepare_freeze_tuple always freezes pg_upgrade'd xmax */
7957 freeze = true;
7958 }
7959 else
7960 {
7961 /* xmax is a MultiXactId that may have an updater XID */
7962 MultiXactMember *members;
7963 int nmembers;
7964
7967 *NoFreezePageRelminMxid = multi;
7969 freeze = true;
7970
7971 /* need to check whether any member of the mxact is old */
7974
7976 {
7980 *NoFreezePageRelfrozenXid = xid;
7982 freeze = true;
7983 }
7984 if (nmembers > 0)
7985 pfree(members);
7986 }
7987
7989 {
7990 xid = HeapTupleHeaderGetXvac(tuple);
7992 {
7995 *NoFreezePageRelfrozenXid = xid;
7996 /* heap_prepare_freeze_tuple forces xvac freezing */
7997 freeze = true;
7998 }
7999 }
8000
8001 return freeze;
8002}
bool MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:2847
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 3276 of file heapam.c.
3280{
3281 TM_Result result;
3283 Bitmapset *hot_attrs;
3284 Bitmapset *sum_attrs;
3285 Bitmapset *key_attrs;
3286 Bitmapset *id_attrs;
3287 Bitmapset *interesting_attrs;
3288 Bitmapset *modified_attrs;
3289 ItemId lp;
3290 HeapTupleData oldtup;
3291 HeapTuple heaptup;
3292 HeapTuple old_key_tuple = NULL;
3293 bool old_key_copied = false;
3294 Page page;
3295 BlockNumber block;
3296 MultiXactStatus mxact_status;
3297 Buffer buffer,
3298 newbuf,
3299 vmbuffer = InvalidBuffer,
3300 vmbuffer_new = InvalidBuffer;
3301 bool need_toast;
3302 Size newtupsize,
3303 pagefree;
3304 bool have_tuple_lock = false;
3305 bool iscombo;
3306 bool use_hot_update = false;
3307 bool summarized_update = false;
3308 bool key_intact;
3309 bool all_visible_cleared = false;
3310 bool all_visible_cleared_new = false;
3311 bool checked_lockers;
3312 bool locker_remains;
3313 bool id_has_external = false;
3314 TransactionId xmax_new_tuple,
3315 xmax_old_tuple;
3316 uint16 infomask_old_tuple,
3317 infomask2_old_tuple,
3318 infomask_new_tuple,
3319 infomask2_new_tuple;
3320
3322
3323 /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
3325 RelationGetNumberOfAttributes(relation));
3326
3327 AssertHasSnapshotForToast(relation);
3328
3329 /*
3330 * Forbid this during a parallel operation, lest it allocate a combo CID.
3331 * Other workers might need that combo CID for visibility checks, and we
3332 * have no provision for broadcasting it to them.
3333 */
3336 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3338
3339#ifdef USE_ASSERT_CHECKING
3340 check_lock_if_inplace_updateable_rel(relation, otid, newtup);
3341#endif
3342
3343 /*
3344 * Fetch the list of attributes to be checked for various operations.
3345 *
3346 * For HOT considerations, this is wasted effort if we fail to update or
3347 * have to put the new tuple on a different page. But we must compute the
3348 * list before obtaining buffer lock --- in the worst case, if we are
3349 * doing an update on one of the relevant system catalogs, we could
3350 * deadlock if we try to fetch the list later. In any case, the relcache
3351 * caches the data so this is usually pretty cheap.
3352 *
3353 * We also need columns used by the replica identity and columns that are
3354 * considered the "key" of rows in the table.
3355 *
3356 * Note that we get copies of each bitmap, so we need not worry about
3357 * relcache flush happening midway through.
3358 */
3359 hot_attrs = RelationGetIndexAttrBitmap(relation,
3361 sum_attrs = RelationGetIndexAttrBitmap(relation,
3362 INDEX_ATTR_BITMAP_SUMMARIZED);
3364 id_attrs = RelationGetIndexAttrBitmap(relation,
3366 interesting_attrs = NULL;
3367 interesting_attrs = bms_add_members(interesting_attrs, hot_attrs);
3368 interesting_attrs = bms_add_members(interesting_attrs, sum_attrs);
3369 interesting_attrs = bms_add_members(interesting_attrs, key_attrs);
3370 interesting_attrs = bms_add_members(interesting_attrs, id_attrs);
3371
3372 block = ItemPointerGetBlockNumber(otid);
3374 buffer = ReadBuffer(relation, block);
3375 page = BufferGetPage(buffer);
3376
3377 /*
3378 * Before locking the buffer, pin the visibility map page if it appears to
3379 * be necessary. Since we haven't got the lock yet, someone else might be
3380 * in the middle of changing this, so we'll need to recheck after we have
3381 * the lock.
3382 */
3384 visibilitymap_pin(relation, block, &vmbuffer);
3385
3387
3389
3390 /*
3391 * Usually, a buffer pin and/or snapshot blocks pruning of otid, ensuring
3392 * we see LP_NORMAL here. When the otid origin is a syscache, we may have
3393 * neither a pin nor a snapshot. Hence, we may see other LP_ states, each
3394 * of which indicates concurrent pruning.
3395 *
3396 * Failing with TM_Updated would be most accurate. However, unlike other
3397 * TM_Updated scenarios, we don't know the successor ctid in LP_UNUSED and
3398 * LP_DEAD cases. While the distinction between TM_Updated and TM_Deleted
3399 * does matter to SQL statements UPDATE and MERGE, those SQL statements
3400 * hold a snapshot that ensures LP_NORMAL. Hence, the choice between
3401 * TM_Updated and TM_Deleted affects only the wording of error messages.
3402 * Settle on TM_Deleted, for two reasons. First, it avoids complicating
3403 * the specification of when tmfd->ctid is valid. Second, it creates
3404 * error log evidence that we took this branch.
3405 *
3406 * Since it's possible to see LP_UNUSED at otid, it's also possible to see
3407 * LP_NORMAL for a tuple that replaced LP_UNUSED. If it's a tuple for an
3408 * unrelated row, we'll fail with "duplicate key value violates unique".
3409 * XXX if otid is the live, newer version of the newtup row, we'll discard
3410 * changes originating in versions of this catalog row after the version
3411 * the caller got from syscache. See syscache-update-pruned.spec.
3412 */
3414 {
3416
3417 UnlockReleaseBuffer(buffer);
3418 Assert(!have_tuple_lock);
3420 ReleaseBuffer(vmbuffer);
3421 tmfd->ctid = *otid;
3424 *update_indexes = TU_None;
3425
3426 bms_free(hot_attrs);
3427 bms_free(sum_attrs);
3428 bms_free(key_attrs);
3429 bms_free(id_attrs);
3430 /* modified_attrs not yet initialized */
3431 bms_free(interesting_attrs);
3433 }
3434
3435 /*
3436 * Fill in enough data in oldtup for HeapDetermineColumnsInfo to work
3437 * properly.
3438 */
3442 oldtup.t_self = *otid;
3443
3444 /* the new tuple is ready, except for this: */
3446
3447 /*
3448 * Determine columns modified by the update. Additionally, identify
3449 * whether any of the unmodified replica identity key attributes in the
3450 * old tuple is externally stored or not. This is required because for
3451 * such attributes the flattened value won't be WAL logged as part of the
3452 * new tuple so we must include it as part of the old_key_tuple. See
3453 * ExtractReplicaIdentity.
3454 */
3455 modified_attrs = HeapDetermineColumnsInfo(relation, interesting_attrs,
3456 id_attrs, &oldtup,
3457 newtup, &id_has_external);
3458
3459 /*
3460 * If we're not updating any "key" column, we can grab a weaker lock type.
3461 * This allows for more concurrency when we are running simultaneously
3462 * with foreign key checks.
3463 *
3464 * Note that if a column gets detoasted while executing the update, but
3465 * the value ends up being the same, this test will fail and we will use
3466 * the stronger lock. This is acceptable; the important case to optimize
3467 * is updates that don't manipulate key columns, not those that
3468 * serendipitously arrive at the same key values.
3469 */
3471 {
3472 *lockmode = LockTupleNoKeyExclusive;
3473 mxact_status = MultiXactStatusNoKeyUpdate;
3474 key_intact = true;
3475
3476 /*
3477 * If this is the first possibly-multixact-able operation in the
3478 * current transaction, set my per-backend OldestMemberMXactId
3479 * setting. We can be certain that the transaction will never become a
3480 * member of any older MultiXactIds than that. (We have to do this
3481 * even if we end up just using our own TransactionId below, since
3482 * some other backend could incorporate our XID into a MultiXact
3483 * immediately afterwards.)
3484 */
3485 MultiXactIdSetOldestMember();
3486 }
3487 else
3488 {
3489 *lockmode = LockTupleExclusive;
3490 mxact_status = MultiXactStatusUpdate;
3491 key_intact = false;
3492 }
3493
3494 /*
3495 * Note: beyond this point, use oldtup not otid to refer to old tuple.
3496 * otid may very well point at newtup->t_self, which we will overwrite
3497 * with the new tuple's location, so there's great risk of confusion if we
3498 * use otid anymore.
3499 */
3500
3501l2:
3502 checked_lockers = false;
3503 locker_remains = false;
3504 result = HeapTupleSatisfiesUpdate(&oldtup, cid, buffer);
3505
3506 /* see below about the "no wait" case */
3508
3510 {
3511 UnlockReleaseBuffer(buffer);
3513 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
3515 }
3517 {
3518 TransactionId xwait;
3519 uint16 infomask;
3520 bool can_continue = false;
3521
3522 /*
3523 * XXX note that we don't consider the "no wait" case here. This
3524 * isn't a problem currently because no caller uses that case, but it
3525 * should be fixed if such a caller is introduced. It wasn't a
3526 * problem previously because this code would always wait, but now
3527 * that some tuple locks do not conflict with one of the lock modes we
3528 * use, it is possible that this case is interesting to handle
3529 * specially.
3530 *
3531 * This may cause failures with third-party code that calls
3532 * heap_update directly.
3533 */
3534
3535 /* must copy state data before unlocking buffer */
3538
3539 /*
3540 * Now we have to do something about the existing locker. If it's a
3541 * multi, sleep on it; we might be awakened before it is completely
3542 * gone (or even not sleep at all in some cases); we need to preserve
3543 * it as locker, unless it is gone completely.
3544 *
3545 * If it's not a multi, we need to check for sleeping conditions
3546 * before actually going to sleep. If the update doesn't conflict
3547 * with the locks, we just continue without sleeping (but making sure
3548 * it is preserved).
3549 *
3550 * Before sleeping, we need to acquire tuple lock to establish our
3551 * priority for the tuple (see heap_lock_tuple). LockTuple will
3552 * release us when we are next-in-line for the tuple. Note we must
3553 * not acquire the tuple lock until we're sure we're going to sleep;
3554 * otherwise we're open for race conditions with other transactions
3555 * holding the tuple lock which sleep on us.
3556 *
3557 * If we are forced to "start over" below, we keep the tuple lock;
3558 * this arranges that we stay at the head of the line while rechecking
3559 * tuple state.
3560 */
3562 {
3563 TransactionId update_xact;
3564 int remain;
3565 bool current_is_member = false;
3566
3568 *lockmode, ¤t_is_member))
3569 {
3571
3572 /*
3573 * Acquire the lock, if necessary (but skip it when we're
3574 * requesting a lock and already have one; avoids deadlock).
3575 */
3576 if (!current_is_member)
3578 LockWaitBlock, &have_tuple_lock);
3579
3580 /* wait for multixact */
3583 &remain);
3584 checked_lockers = true;
3585 locker_remains = remain != 0;
3587
3588 /*
3589 * If xwait had just locked the tuple then some other xact
3590 * could update this tuple before we get to this point. Check
3591 * for xmax change, and start over if so.
3592 */
3594 infomask) ||
3596 xwait))
3597 goto l2;
3598 }
3599
3600 /*
3601 * Note that the multixact may not be done by now. It could have
3602 * surviving members; our own xact or other subxacts of this
3603 * backend, and also any other concurrent transaction that locked
3604 * the tuple with LockTupleKeyShare if we only got
3605 * LockTupleNoKeyExclusive. If this is the case, we have to be
3606 * careful to mark the updated tuple with the surviving members in
3607 * Xmax.
3608 *
3609 * Note that there could have been another update in the
3610 * MultiXact. In that case, we need to check whether it committed
3611 * or aborted. If it aborted we are safe to update it again;
3612 * otherwise there is an update conflict, and we have to return
3613 * TableTuple{Deleted, Updated} below.
3614 *
3615 * In the LockTupleExclusive case, we still need to preserve the
3616 * surviving members: those would include the tuple locks we had
3617 * before this one, which are important to keep in case this
3618 * subxact aborts.
3619 */
3622 else
3623 update_xact = InvalidTransactionId;
3624
3625 /*
3626 * There was no UPDATE in the MultiXact; or it aborted. No
3627 * TransactionIdIsInProgress() call needed here, since we called
3628 * MultiXactIdWait() above.
3629 */
3631 TransactionIdDidAbort(update_xact))
3632 can_continue = true;
3633 }
3635 {
3636 /*
3637 * The only locker is ourselves; we can avoid grabbing the tuple
3638 * lock here, but must preserve our locking information.
3639 */
3640 checked_lockers = true;
3641 locker_remains = true;
3642 can_continue = true;
3643 }
3645 {
3646 /*
3647 * If it's just a key-share locker, and we're not changing the key
3648 * columns, we don't need to wait for it to end; but we need to
3649 * preserve it as locker.
3650 */
3651 checked_lockers = true;
3652 locker_remains = true;
3653 can_continue = true;
3654 }
3655 else
3656 {
3657 /*
3658 * Wait for regular transaction to end; but first, acquire tuple
3659 * lock.
3660 */
3663 LockWaitBlock, &have_tuple_lock);
3665 XLTW_Update);
3666 checked_lockers = true;
3668
3669 /*
3670 * xwait is done, but if xwait had just locked the tuple then some
3671 * other xact could update this tuple before we get to this point.
3672 * Check for xmax change, and start over if so.
3673 */
3675 !TransactionIdEquals(xwait,
3677 goto l2;
3678
3679 /* Otherwise check if it committed or aborted */
3682 can_continue = true;
3683 }
3684
3685 if (can_continue)
3686 result = TM_Ok;
3688 result = TM_Updated;
3689 else
3690 result = TM_Deleted;
3691 }
3692
3693 /* Sanity check the result HeapTupleSatisfiesUpdate() and the logic above */
3695 {
3697 result == TM_Updated ||
3698 result == TM_Deleted ||
3699 result == TM_BeingModified);
3703 }
3704
3706 {
3707 /* Perform additional check for transaction-snapshot mode RI updates */
3709 result = TM_Updated;
3710 }
3711
3713 {
3718 else
3720 UnlockReleaseBuffer(buffer);
3721 if (have_tuple_lock)
3724 ReleaseBuffer(vmbuffer);
3725 *update_indexes = TU_None;
3726
3727 bms_free(hot_attrs);
3728 bms_free(sum_attrs);
3729 bms_free(key_attrs);
3730 bms_free(id_attrs);
3731 bms_free(modified_attrs);
3732 bms_free(interesting_attrs);
3733 return result;
3734 }
3735
3736 /*
3737 * If we didn't pin the visibility map page and the page has become all
3738 * visible while we were busy locking the buffer, or during some
3739 * subsequent window during which we had it unlocked, we'll have to unlock
3740 * and re-lock, to avoid holding the buffer lock across an I/O. That's a
3741 * bit unfortunate, especially since we'll now have to recheck whether the
3742 * tuple has been locked or updated under us, but hopefully it won't
3743 * happen very often.
3744 */
3746 {
3748 visibilitymap_pin(relation, block, &vmbuffer);
3750 goto l2;
3751 }
3752
3753 /* Fill in transaction status data */
3754
3755 /*
3756 * If the tuple we're updating is locked, we need to preserve the locking
3757 * info in the old tuple's Xmax. Prepare a new Xmax value for this.
3758 */
3762 xid, *lockmode, true,
3763 &xmax_old_tuple, &infomask_old_tuple,
3764 &infomask2_old_tuple);
3765
3766 /*
3767 * And also prepare an Xmax value for the new copy of the tuple. If there
3768 * was no xmax previously, or there was one but all lockers are now gone,
3769 * then use InvalidTransactionId; otherwise, get the xmax from the old
3770 * tuple. (In rare cases that might also be InvalidTransactionId and yet
3771 * not have the HEAP_XMAX_INVALID bit set; that's fine.)
3772 */
3775 (checked_lockers && !locker_remains))
3776 xmax_new_tuple = InvalidTransactionId;
3777 else
3779
3781 {
3782 infomask_new_tuple = HEAP_XMAX_INVALID;
3783 infomask2_new_tuple = 0;
3784 }
3785 else
3786 {
3787 /*
3788 * If we found a valid Xmax for the new tuple, then the infomask bits
3789 * to use on the new tuple depend on what was there on the old one.
3790 * Note that since we're doing an update, the only possibility is that
3791 * the lockers had FOR KEY SHARE lock.
3792 */
3794 {
3795 GetMultiXactIdHintBits(xmax_new_tuple, &infomask_new_tuple,
3796 &infomask2_new_tuple);
3797 }
3798 else
3799 {
3801 infomask2_new_tuple = 0;
3802 }
3803 }
3804
3805 /*
3806 * Prepare the new tuple with the appropriate initial values of Xmin and
3807 * Xmax, as well as initial infomask bits as computed above.
3808 */
3816
3817 /*
3818 * Replace cid with a combo CID if necessary. Note that we already put
3819 * the plain cid into the new tuple.
3820 */
3822
3823 /*
3824 * If the toaster needs to be activated, OR if the new tuple will not fit
3825 * on the same page as the old, then we need to release the content lock
3826 * (but not the pin!) on the old tuple's buffer while we are off doing
3827 * TOAST and/or table-file-extension work. We must mark the old tuple to
3828 * show that it's locked, else other processes may try to update it
3829 * themselves.
3830 *
3831 * We need to invoke the toaster if there are already any out-of-line
3832 * toasted values present, or if the new tuple is over-threshold.
3833 */
3835 relation->rd_rel->relkind != RELKIND_MATVIEW)
3836 {
3837 /* toast table entries should never be recursively toasted */
3840 need_toast = false;
3841 }
3842 else
3843 need_toast = (HeapTupleHasExternal(&oldtup) ||
3844 HeapTupleHasExternal(newtup) ||
3846
3847 pagefree = PageGetHeapFreeSpace(page);
3848
3850
3851 if (need_toast || newtupsize > pagefree)
3852 {
3853 TransactionId xmax_lock_old_tuple;
3854 uint16 infomask_lock_old_tuple,
3855 infomask2_lock_old_tuple;
3856 bool cleared_all_frozen = false;
3857
3858 /*
3859 * To prevent concurrent sessions from updating the tuple, we have to
3860 * temporarily mark it locked, while we release the page-level lock.
3861 *
3862 * To satisfy the rule that any xid potentially appearing in a buffer
3863 * written out to disk, we unfortunately have to WAL log this
3864 * temporary modification. We can reuse xl_heap_lock for this
3865 * purpose. If we crash/error before following through with the
3866 * actual update, xmax will be of an aborted transaction, allowing
3867 * other sessions to proceed.
3868 */
3869
3870 /*
3871 * Compute xmax / infomask appropriate for locking the tuple. This has
3872 * to be done separately from the combo that's going to be used for
3873 * updating, because the potentially created multixact would otherwise
3874 * be wrong.
3875 */
3879 xid, *lockmode, false,
3880 &xmax_lock_old_tuple, &infomask_lock_old_tuple,
3881 &infomask2_lock_old_tuple);
3882
3884
3885 START_CRIT_SECTION();
3886
3887 /* Clear obsolete visibility flags ... */
3890 HeapTupleClearHotUpdated(&oldtup);
3891 /* ... and store info about transaction updating this tuple */
3897
3898 /* temporarily make it look not-updated, but locked */
3900
3901 /*
3902 * Clear all-frozen bit on visibility map if needed. We could
3903 * immediately reset ALL_VISIBLE, but given that the WAL logging
3904 * overhead would be unchanged, that doesn't seem necessarily
3905 * worthwhile.
3906 */
3908 visibilitymap_clear(relation, block, vmbuffer,
3909 VISIBILITYMAP_ALL_FROZEN))
3910 cleared_all_frozen = true;
3911
3912 MarkBufferDirty(buffer);
3913
3915 {
3916 xl_heap_lock xlrec;
3917 XLogRecPtr recptr;
3918
3919 XLogBeginInsert();
3921
3923 xlrec.xmax = xmax_lock_old_tuple;
3926 xlrec.flags =
3927 cleared_all_frozen ? XLH_LOCK_ALL_FROZEN_CLEARED : 0;
3930 PageSetLSN(page, recptr);
3931 }
3932
3933 END_CRIT_SECTION();
3934
3936
3937 /*
3938 * Let the toaster do its thing, if needed.
3939 *
3940 * Note: below this point, heaptup is the data we actually intend to
3941 * store into the relation; newtup is the caller's original untoasted
3942 * data.
3943 */
3944 if (need_toast)
3945 {
3946 /* Note we always use WAL and FSM during updates */
3947 heaptup = heap_toast_insert_or_update(relation, newtup, &oldtup, 0);
3949 }
3950 else
3951 heaptup = newtup;
3952
3953 /*
3954 * Now, do we need a new page for the tuple, or not? This is a bit
3955 * tricky since someone else could have added tuples to the page while
3956 * we weren't looking. We have to recheck the available space after
3957 * reacquiring the buffer lock. But don't bother to do that if the
3958 * former amount of free space is still not enough; it's unlikely
3959 * there's more free now than before.
3960 *
3961 * What's more, if we need to get a new page, we will need to acquire
3962 * buffer locks on both old and new pages. To avoid deadlock against
3963 * some other backend trying to get the same two locks in the other
3964 * order, we must be consistent about the order we get the locks in.
3965 * We use the rule "lock the lower-numbered page of the relation
3966 * first". To implement this, we must do RelationGetBufferForTuple
3967 * while not holding the lock on the old page, and we must rely on it
3968 * to get the locks on both pages in the correct order.
3969 *
3970 * Another consideration is that we need visibility map page pin(s) if
3971 * we will have to clear the all-visible flag on either page. If we
3972 * call RelationGetBufferForTuple, we rely on it to acquire any such
3973 * pins; but if we don't, we have to handle that here. Hence we need
3974 * a loop.
3975 */
3976 for (;;)
3977 {
3978 if (newtupsize > pagefree)
3979 {
3980 /* It doesn't fit, must use RelationGetBufferForTuple. */
3982 buffer, 0, NULL,
3983 &vmbuffer_new, &vmbuffer,
3984 0);
3985 /* We're all done. */
3986 break;
3987 }
3988 /* Acquire VM page pin if needed and we don't have it. */
3990 visibilitymap_pin(relation, block, &vmbuffer);
3991 /* Re-acquire the lock on the old tuple's page. */
3993 /* Re-check using the up-to-date free space */
3994 pagefree = PageGetHeapFreeSpace(page);
3995 if (newtupsize > pagefree ||
3997 {
3998 /*
3999 * Rats, it doesn't fit anymore, or somebody just now set the
4000 * all-visible flag. We must now unlock and loop to avoid
4001 * deadlock. Fortunately, this path should seldom be taken.
4002 */
4004 }
4005 else
4006 {
4007 /* We're all done. */
4008 newbuf = buffer;
4009 break;
4010 }
4011 }
4012 }
4013 else
4014 {
4015 /* No TOAST work needed, and it'll fit on same page */
4016 newbuf = buffer;
4017 heaptup = newtup;
4018 }
4019
4020 /*
4021 * We're about to do the actual update -- check for conflict first, to
4022 * avoid possibly having to roll back work we've just done.
4023 *
4024 * This is safe without a recheck as long as there is no possibility of
4025 * another process scanning the pages between this check and the update
4026 * being visible to the scan (i.e., exclusive buffer content lock(s) are
4027 * continuously held from this point until the tuple update is visible).
4028 *
4029 * For the new tuple the only check needed is at the relation level, but
4030 * since both tuples are in the same relation and the check for oldtup
4031 * will include checking the relation level, there is no benefit to a
4032 * separate check for the new tuple.
4033 */
4035 BufferGetBlockNumber(buffer));
4036
4037 /*
4038 * At this point newbuf and buffer are both pinned and locked, and newbuf
4039 * has enough space for the new tuple. If they are the same buffer, only
4040 * one pin is held.
4041 */
4042
4043 if (newbuf == buffer)
4044 {
4045 /*
4046 * Since the new tuple is going into the same page, we might be able
4047 * to do a HOT update. Check if any of the index columns have been
4048 * changed.
4049 */
4051 {
4052 use_hot_update = true;
4053
4054 /*
4055 * If none of the columns that are used in hot-blocking indexes
4056 * were updated, we can apply HOT, but we do still need to check
4057 * if we need to update the summarizing indexes, and update those
4058 * indexes if the columns were updated, or we may fail to detect
4059 * e.g. value bound changes in BRIN minmax indexes.
4060 */
4062 summarized_update = true;
4063 }
4064 }
4065 else
4066 {
4067 /* Set a hint that the old page could use prune/defrag */
4068 PageSetFull(page);
4069 }
4070
4071 /*
4072 * Compute replica identity tuple before entering the critical section so
4073 * we don't PANIC upon a memory allocation failure.
4074 * ExtractReplicaIdentity() will return NULL if nothing needs to be
4075 * logged. Pass old key required as true only if the replica identity key
4076 * columns are modified or it has external data.
4077 */
4078 old_key_tuple = ExtractReplicaIdentity(relation, &oldtup,
4079 bms_overlap(modified_attrs, id_attrs) ||
4080 id_has_external,
4081 &old_key_copied);
4082
4083 /* NO EREPORT(ERROR) from here till changes are logged */
4084 START_CRIT_SECTION();
4085
4086 /*
4087 * If this transaction commits, the old tuple will become DEAD sooner or
4088 * later. Set flag that this page is a candidate for pruning once our xid
4089 * falls below the OldestXmin horizon. If the transaction finally aborts,
4090 * the subsequent page pruning will be a no-op and the hint will be
4091 * cleared.
4092 *
4093 * XXX Should we set hint on newbuf as well? If the transaction aborts,
4094 * there would be a prunable tuple in the newbuf; but for now we choose
4095 * not to optimize for aborts. Note that heap_xlog_update must be kept in
4096 * sync if this decision changes.
4097 */
4098 PageSetPrunable(page, xid);
4099
4100 if (use_hot_update)
4101 {
4102 /* Mark the old tuple as HOT-updated */
4103 HeapTupleSetHotUpdated(&oldtup);
4104 /* And mark the new tuple as heap-only */
4105 HeapTupleSetHeapOnly(heaptup);
4106 /* Mark the caller's copy too, in case different from heaptup */
4107 HeapTupleSetHeapOnly(newtup);
4108 }
4109 else
4110 {
4111 /* Make sure tuples are correctly marked as not-HOT */
4112 HeapTupleClearHotUpdated(&oldtup);
4113 HeapTupleClearHeapOnly(heaptup);
4114 HeapTupleClearHeapOnly(newtup);
4115 }
4116
4118
4119
4120 /* Clear obsolete visibility flags, possibly set by ourselves above... */
4123 /* ... and store info about transaction updating this tuple */
4129
4130 /* record address of new tuple in t_ctid of old one */
4132
4133 /* clear PD_ALL_VISIBLE flags, reset all visibilitymap bits */
4135 {
4136 all_visible_cleared = true;
4139 vmbuffer, VISIBILITYMAP_VALID_BITS);
4140 }
4142 {
4143 all_visible_cleared_new = true;
4146 vmbuffer_new, VISIBILITYMAP_VALID_BITS);
4147 }
4148
4149 if (newbuf != buffer)
4150 MarkBufferDirty(newbuf);
4151 MarkBufferDirty(buffer);
4152
4153 /* XLOG stuff */
4155 {
4156 XLogRecPtr recptr;
4157
4158 /*
4159 * For logical decoding we need combo CIDs to properly decode the
4160 * catalog.
4161 */
4163 {
4164 log_heap_new_cid(relation, &oldtup);
4165 log_heap_new_cid(relation, heaptup);
4166 }
4167
4168 recptr = log_heap_update(relation, buffer,
4169 newbuf, &oldtup, heaptup,
4170 old_key_tuple,
4171 all_visible_cleared,
4172 all_visible_cleared_new);
4173 if (newbuf != buffer)
4174 {
4176 }
4178 }
4179
4180 END_CRIT_SECTION();
4181
4182 if (newbuf != buffer)
4185
4186 /*
4187 * Mark old tuple for invalidation from system caches at next command
4188 * boundary, and mark the new tuple for invalidation in case we abort. We
4189 * have to do this before releasing the buffer because oldtup is in the
4190 * buffer. (heaptup is all in local memory, but it's necessary to process
4191 * both tuple versions in one call to inval.c so we can avoid redundant
4192 * sinval messages.)
4193 */
4194 CacheInvalidateHeapTuple(relation, &oldtup, heaptup);
4195
4196 /* Now we can release the buffer(s) */
4197 if (newbuf != buffer)
4198 ReleaseBuffer(newbuf);
4199 ReleaseBuffer(buffer);
4201 ReleaseBuffer(vmbuffer_new);
4203 ReleaseBuffer(vmbuffer);
4204
4205 /*
4206 * Release the lmgr tuple lock, if we had it.
4207 */
4208 if (have_tuple_lock)
4210
4211 pgstat_count_heap_update(relation, use_hot_update, newbuf != buffer);
4212
4213 /*
4214 * If heaptup is a private copy, release it. Don't forget to copy t_self
4215 * back to the caller's image, too.
4216 */
4217 if (heaptup != newtup)
4218 {
4220 heap_freetuple(heaptup);
4221 }
4222
4223 /*
4224 * If it is a HOT update, the update may still need to update summarized
4225 * indexes, lest we fail to update those summaries and get incorrect
4226 * results (for example, minmax bounds of the block may change with this
4227 * update).
4228 */
4229 if (use_hot_update)
4230 {
4231 if (summarized_update)
4232 *update_indexes = TU_Summarizing;
4233 else
4234 *update_indexes = TU_None;
4235 }
4236 else
4237 *update_indexes = TU_All;
4238
4239 if (old_key_tuple != NULL && old_key_copied)
4240 heap_freetuple(old_key_tuple);
4241
4242 bms_free(hot_attrs);
4243 bms_free(sum_attrs);
4244 bms_free(key_attrs);
4245 bms_free(id_attrs);
4246 bms_free(modified_attrs);
4247 bms_free(interesting_attrs);
4248
4250}
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:4430
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:8883
TransactionId HeapTupleGetUpdateXid(const HeapTupleHeaderData *tup)
Definition: heapam.c:7624
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:388
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 9290 of file heapam.c.
9293{
9294 TransactionId xid;
9295 HTSV_Result htsvResult;
9296
9298 return;
9299
9300 /*
9301 * Check to see whether the tuple has been written to by a concurrent
9302 * transaction, either to create it not visible to us, or to delete it
9303 * while it is visible to us. The "visible" bool indicates whether the
9304 * tuple is visible to us, while HeapTupleSatisfiesVacuum checks what else
9305 * is going on with it.
9306 *
9307 * In the event of a concurrently inserted tuple that also happens to have
9308 * been concurrently updated (by a separate transaction), the xmin of the
9309 * tuple will be used -- not the updater's xid.
9310 */
9312 switch (htsvResult)
9313 {
9315 if (visible)
9316 return;
9318 break;
9321 if (visible)
9323 else
9325
9327 {
9328 /* This is like the HEAPTUPLE_DEAD case */
9329 Assert(!visible);
9330 return;
9331 }
9332 break;
9335 break;
9337 Assert(!visible);
9338 return;
9339 default:
9340
9341 /*
9342 * The only way to get to this default clause is if a new value is
9343 * added to the enum type without adding it to this switch
9344 * statement. That's a bug, so elog.
9345 */
9347
9348 /*
9349 * In spite of having all enum values covered and calling elog on
9350 * this default, some compilers think this is a code path which
9351 * allows xid to be used below without initialization. Silence
9352 * that warning.
9353 */
9354 xid = InvalidTransactionId;
9355 }
9356
9359
9360 /*
9361 * Find top level xid. Bail out if xid is too early to be a conflict, or
9362 * if it's our own xid.
9363 */
9365 return;
9366 xid = SubTransGetTopmostTransaction(xid);
9368 return;
9369
9370 CheckForSerializableConflictOut(relation, xid, snapshot);
9371}
HTSV_Result HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin, Buffer buffer)
Definition: heapam_visibility.c:1035
void CheckForSerializableConflictOut(Relation relation, TransactionId xid, Snapshot snapshot)
Definition: predicate.c:4021
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 4430 of file heapam.c.
4435{
4436 int attidx;
4437 Bitmapset *modified = NULL;
4439
4440 attidx = -1;
4442 {
4443 /* attidx is zero-based, attrnum is the normal attribute number */
4445 Datum value1,
4446 value2;
4447 bool isnull1,
4448 isnull2;
4449
4450 /*
4451 * If it's a whole-tuple reference, say "not equal". It's not really
4452 * worth supporting this case, since it could only succeed after a
4453 * no-op update, which is hardly a case worth optimizing for.
4454 */
4455 if (attrnum == 0)
4456 {
4457 modified = bms_add_member(modified, attidx);
4458 continue;
4459 }
4460
4461 /*
4462 * Likewise, automatically say "not equal" for any system attribute
4463 * other than tableOID; we cannot expect these to be consistent in a
4464 * HOT chain, or even to be set correctly yet in the new tuple.
4465 */
4466 if (attrnum < 0)
4467 {
4469 {
4470 modified = bms_add_member(modified, attidx);
4471 continue;
4472 }
4473 }
4474
4475 /*
4476 * Extract the corresponding values. XXX this is pretty inefficient
4477 * if there are many indexed columns. Should we do a single
4478 * heap_deform_tuple call on each tuple, instead? But that doesn't
4479 * work for system columns ...
4480 */
4481 value1 = heap_getattr(oldtup, attrnum, tupdesc, &isnull1);
4482 value2 = heap_getattr(newtup, attrnum, tupdesc, &isnull2);
4483
4485 value2, isnull1, isnull2))
4486 {
4487 modified = bms_add_member(modified, attidx);
4488 continue;
4489 }
4490
4491 /*
4492 * No need to check attributes that can't be stored externally. Note
4493 * that system attributes can't be stored externally.
4494 */
4495 if (attrnum < 0 || isnull1 ||
4497 continue;
4498
4499 /*
4500 * Check if the old tuple's attribute is stored externally and is a
4501 * member of external_cols.
4502 */
4504 bms_is_member(attidx, external_cols))
4505 *has_external = true;
4506 }
4507
4508 return modified;
4509}
static bool heap_attr_equals(TupleDesc tupdesc, int attrnum, Datum value1, Datum value2, bool isnull1, bool isnull2)
Definition: heapam.c:4379
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 914 of file heapam.c.
918{
920 Page page;
921 OffsetNumber lineoff;
922 int linesleft;
923
925 {
926 /* continue from previously returned page/tuple */
928 page = heapgettup_continue_page(scan, dir, &linesleft, &lineoff);
929 goto continue_page;
930 }
931
932 /*
933 * advance the scan until we find a qualifying tuple or run out of stuff
934 * to scan
935 */
936 while (true)
937 {
938 heap_fetch_next_buffer(scan, dir);
939
940 /* did we run out of blocks to scan? */
942 break;
943
945
947 page = heapgettup_start_page(scan, dir, &linesleft, &lineoff);
948continue_page:
949
950 /*
951 * Only continue scanning the page while we have lines left.
952 *
953 * Note that this protects us from accessing line pointers past
954 * PageGetMaxOffsetNumber(); both for forward scans when we resume the
955 * table scan, and for when we start scanning a new page.
956 */
957 for (; linesleft > 0; linesleft--, lineoff += dir)
958 {
959 bool visible;
961
963 continue;
964
968
969 visible = HeapTupleSatisfiesVisibility(tuple,
971 scan->rs_cbuf);
972
974 tuple, scan->rs_cbuf,
976
977 /* skip tuples not visible to this snapshot */
978 if (!visible)
979 continue;
980
981 /* skip any tuples that don't match the scan key */
984 nkeys, key))
985 continue;
986
988 scan->rs_coffset = lineoff;
989 return;
990 }
991
992 /*
993 * if we get here, it means we've exhausted the items on this page and
994 * it's time to move to the next.
995 */
997 }
998
999 /* end of scan */
1002
1006 tuple->t_data = NULL;
1008}
static void heap_fetch_next_buffer(HeapScanDesc scan, ScanDirection dir)
Definition: heapam.c:661
static Page heapgettup_continue_page(HeapScanDesc scan, ScanDirection dir, int *linesleft, OffsetNumber *lineoff)
Definition: heapam.c:784
static Page heapgettup_start_page(HeapScanDesc scan, ScanDirection dir, int *linesleft, OffsetNumber *lineoff)
Definition: heapam.c:753
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 830 of file heapam.c.
831{
833
835 {
836 block++;
837
838 /* wrap back to the start of the heap */
840 block = 0;
841
842 /*
843 * Report our new scan position for synchronization purposes. We don't
844 * do that when moving backwards, however. That would just mess up any
845 * other forward-moving scanners.
846 *
847 * Note: we do this before checking for end of scan so that the final
848 * state of the position hint is back at the start of the rel. That's
849 * not strictly necessary, but otherwise when you run the same query
850 * multiple times the starting position would shift a little bit
851 * backwards on every invocation, which is confusing. We don't
852 * guarantee any specific ordering in general, though.
853 */
856
857 /* we're done if we're back at where we started */
860
861 /* check if the limit imposed by heap_setscanlimits() is met */
863 {
866 }
867
868 return block;
869 }
870 else
871 {
872 /* we're done if the last block is the start position */
875
876 /* check if the limit imposed by heap_setscanlimits() is met */
878 {
881 }
882
883 /* wrap to the end of the heap when the last page was page 0 */
884 if (block == 0)
885 block = scan->rs_nblocks;
886
887 block--;
888
889 return block;
890 }
891}
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 784 of file heapam.c.
786{
787 Page page;
788
791
792 /* Caller is responsible for ensuring buffer is locked if needed */
794
796 {
798 *linesleft = PageGetMaxOffsetNumber(page) - (*lineoff) + 1;
799 }
800 else
801 {
802 /*
803 * The previous returned tuple may have been vacuumed since the
804 * previous scan when we use a non-MVCC snapshot, so we must
805 * re-establish the lineoff <= PageGetMaxOffsetNumber(page) invariant
806 */
808 *linesleft = *lineoff;
809 }
810
811 /* lineoff now references the physically previous or next tid */
812 return page;
813}
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 706 of file heapam.c.
707{
710
711 /* When there are no pages to scan, return InvalidBlockNumber */
714
716 {
718 }
719 else
720 {
721 /*
722 * Disable reporting to syncscan logic in a backwards scan; it's not
723 * very likely anyone else is doing the same thing at the same time,
724 * and much more likely that we'll just bollix things for forward
725 * scanners.
726 */
728
729 /*
730 * Start from last page of the scan. Ensure we take into account
731 * rs_numblocks if it's been adjusted by heap_setscanlimits().
732 */
735
738
740 }
741}
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 1024 of file heapam.c.
1028{
1030 Page page;
1031 uint32 lineindex;
1032 uint32 linesleft;
1033
1035 {
1036 /* continue from previously returned page/tuple */
1038
1039 lineindex = scan->rs_cindex + dir;
1041 linesleft = scan->rs_ntuples - lineindex;
1042 else
1043 linesleft = scan->rs_cindex;
1044 /* lineindex now references the next or previous visible tid */
1045
1046 goto continue_page;
1047 }
1048
1049 /*
1050 * advance the scan until we find a qualifying tuple or run out of stuff
1051 * to scan
1052 */
1053 while (true)
1054 {
1055 heap_fetch_next_buffer(scan, dir);
1056
1057 /* did we run out of blocks to scan? */
1059 break;
1060
1062
1063 /* prune the page and determine visible tuple offsets */
1066 linesleft = scan->rs_ntuples;
1067 lineindex = ScanDirectionIsForward(dir) ? 0 : linesleft - 1;
1068
1069 /* block is the same for all tuples, set it once outside the loop */
1071
1072 /* lineindex now references the next or previous visible tid */
1073continue_page:
1074
1075 for (; linesleft > 0; linesleft--, lineindex += dir)
1076 {
1077 ItemId lpp;
1078 OffsetNumber lineoff;
1079
1080 Assert(lineindex < scan->rs_ntuples);
1081 lineoff = scan->rs_vistuples[lineindex];
1082 lpp = PageGetItemId(page, lineoff);
1084
1088
1089 /* skip any tuples that don't match the scan key */
1092 nkeys, key))
1093 continue;
1094
1095 scan->rs_cindex = lineindex;
1096 return;
1097 }
1098 }
1099
1100 /* end of scan */
1106 tuple->t_data = NULL;
1108}
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 753 of file heapam.c.
755{
756 Page page;
757
760
761 /* Caller is responsible for ensuring buffer is locked if needed */
763
765
767 *lineoff = FirstOffsetNumber;
768 else
769 *lineoff = (OffsetNumber) (*linesleft);
770
771 /* lineoff now references the physically previous or next tid */
772 return page;
773}
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 7624 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 8018 of file heapam.c.
8020{
8024
8026 {
8028 *snapshotConflictHorizon = xvac;
8029 }
8030
8031 /*
8032 * Ignore tuples inserted by an aborted transaction or if the tuple was
8033 * updated/deleted by the inserting transaction.
8034 *
8035 * Look for a committed hint bit, or if no xmin bit is set, check clog.
8036 */
8039 {
8040 if (xmax != xmin &&
8041 TransactionIdFollows(xmax, *snapshotConflictHorizon))
8042 *snapshotConflictHorizon = xmax;
8043 }
8044}
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 8103 of file heapam.c.
8106{
8108 ItemId iid;
8109
8111
8114 (errcode(ERRCODE_INDEX_CORRUPTED),
8115 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\"",
8116 ItemPointerGetBlockNumber(htid),
8117 indexpagehoffnum,
8120
8121 iid = PageGetItemId(page, indexpagehoffnum);
8124 (errcode(ERRCODE_INDEX_CORRUPTED),
8125 errmsg_internal("heap tid from index tuple (%u,%u) points to unused heap page item at offset %u of block %u in index \"%s\"",
8126 ItemPointerGetBlockNumber(htid),
8127 indexpagehoffnum,
8130
8132 {
8133 HeapTupleHeader htup;
8134
8137
8140 (errcode(ERRCODE_INDEX_CORRUPTED),
8141 errmsg_internal("heap tid from index tuple (%u,%u) points to heap-only tuple at offset %u of block %u in index \"%s\"",
8142 ItemPointerGetBlockNumber(htid),
8143 indexpagehoffnum,
8146 }
8147}
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 8508 of file heapam.c.
8509{
8512
8513 /*
8514 * Shellsort gap sequence (taken from Sedgewick-Incerpi paper).
8515 *
8516 * This implementation is fast with array sizes up to ~4500. This covers
8517 * all supported BLCKSZ values.
8518 */
8519 const int gaps[9] = {1968, 861, 336, 112, 48, 21, 7, 3, 1};
8520
8521 /* Think carefully before changing anything here -- keep swaps cheap */
8523 "element size exceeds 8 bytes");
8524
8526 {
8528 {
8531
8533 {
8535 j -= hi;
8536 }
8537 deltids[j] = d;
8538 }
8539 }
8540}
static int index_delete_sort_cmp(TM_IndexDelete *deltid1, TM_IndexDelete *deltid2)
Definition: heapam.c:8472
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 8472 of file heapam.c.
8473{
8476
8477 {
8480
8481 if (blk1 != blk2)
8482 return (blk1 < blk2) ? -1 : 1;
8483 }
8484 {
8487
8488 if (pos1 != pos2)
8489 return (pos1 < pos2) ? -1 : 1;
8490 }
8491
8493
8494 return 0;
8495}
References Assert(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), and TM_IndexDelete::tid.
Referenced by index_delete_sort().
◆ initscan()
|
static |
Definition at line 355 of file heapam.c.
356{
357 ParallelBlockTableScanDesc bpscan = NULL;
358 bool allow_strat;
359 bool allow_sync;
360
361 /*
362 * Determine the number of blocks we have to scan.
363 *
364 * It is sufficient to do this once at scan start, since any tuples added
365 * while the scan is in progress will be invisible to my snapshot anyway.
366 * (That is not true when using a non-MVCC snapshot. However, we couldn't
367 * guarantee to return tuples added after scan start anyway, since they
368 * might go into pages we already scanned. To guarantee consistent
369 * results for a non-MVCC snapshot, the caller must hold some higher-level
370 * lock that ensures the interesting tuple(s) won't change.)
371 */
373 {
376 }
377 else
379
380 /*
381 * If the table is large relative to NBuffers, use a bulk-read access
382 * strategy and enable synchronized scanning (see syncscan.c). Although
383 * the thresholds for these features could be different, we make them the
384 * same so that there are only two behaviors to tune rather than four.
385 * (However, some callers need to be able to disable one or both of these
386 * behaviors, independently of the size of the table; also there is a GUC
387 * variable that can disable synchronized scanning.)
388 *
389 * Note that table_block_parallelscan_initialize has a very similar test;
390 * if you change this, consider changing that one, too.
391 */
394 {
397 }
398 else
399 allow_strat = allow_sync = false;
400
401 if (allow_strat)
402 {
403 /* During a rescan, keep the previous strategy object. */
406 }
407 else
408 {
411 scan->rs_strategy = NULL;
412 }
413
415 {
416 /* For parallel scan, believe whatever ParallelTableScanDesc says. */
419 else
421
422 /*
423 * If not rescanning, initialize the startblock. Finding the actual
424 * start location is done in table_block_parallelscan_startblock_init,
425 * based on whether an alternative start location has been set with
426 * heap_setscanlimits, or using the syncscan location, when syncscan
427 * is enabled.
428 */
429 if (!keep_startblock)
431 }
432 else
433 {
434 if (keep_startblock)
435 {
436 /*
437 * When rescanning, we want to keep the previous startblock
438 * setting, so that rewinding a cursor doesn't generate surprising
439 * results. Reset the active syncscan setting, though.
440 */
443 else
445 }
447 {
450 }
451 else
452 {
454 scan->rs_startblock = 0;
455 }
456 }
457
464 scan->rs_ntuples = 0;
465 scan->rs_cindex = 0;
466
467 /*
468 * Initialize to ForwardScanDirection because it is most common and
469 * because heap scans go forward before going backward (e.g. CURSORs).
470 */
473
474 /* page-at-a-time fields are always invalid when not rs_inited */
475
476 /*
477 * copy the scan key, if appropriate
478 */
481
482 /*
483 * Currently, we only have a stats counter for sequential heap scans (but
484 * e.g for bitmap scans the underlying bitmap index scans will be counted,
485 * and for sample scans we update stats for tuple fetches).
486 */
489}
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 9105 of file heapam.c.
9106{
9107 xl_heap_new_cid xlrec;
9108
9109 XLogRecPtr recptr;
9111
9114
9118
9119 /*
9120 * If the tuple got inserted & deleted in the same TX we definitely have a
9121 * combo CID, set cmin and cmax.
9122 */
9124 {
9130 }
9131 /* No combo CID, so only cmin or cmax can be set by this TX */
9132 else
9133 {
9134 /*
9135 * Tuple inserted.
9136 *
9137 * We need to check for LOCK ONLY because multixacts might be
9138 * transferred to the new tuple in case of FOR KEY SHARE updates in
9139 * which case there will be an xmax, although the tuple just got
9140 * inserted.
9141 */
9144 {
9147 }
9148 /* Tuple from a different tx updated or deleted. */
9149 else
9150 {
9153 }
9155 }
9156
9157 /*
9158 * Note that we don't need to register the buffer here, because this
9159 * operation does not modify the page. The insert/update/delete that
9160 * called us certainly did, but that's WAL-logged separately.
9161 */
9162 XLogBeginInsert();
9164
9165 /* will be looked at irrespective of origin */
9166
9168
9169 return recptr;
9170}
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 8883 of file heapam.c.
8887{
8888 xl_heap_update xlrec;
8889 xl_heap_header xlhdr;
8890 xl_heap_header xlhdr_idx;
8891 uint8 info;
8892 uint16 prefix_suffix[2];
8893 uint16 prefixlen = 0,
8894 suffixlen = 0;
8895 XLogRecPtr recptr;
8899 int bufflags;
8900
8901 /* Caller should not call me on a non-WAL-logged relation */
8903
8904 XLogBeginInsert();
8905
8907 info = XLOG_HEAP_HOT_UPDATE;
8908 else
8909 info = XLOG_HEAP_UPDATE;
8910
8911 /*
8912 * If the old and new tuple are on the same page, we only need to log the
8913 * parts of the new tuple that were changed. That saves on the amount of
8914 * WAL we need to write. Currently, we just count any unchanged bytes in
8915 * the beginning and end of the tuple. That's quick to check, and
8916 * perfectly covers the common case that only one field is updated.
8917 *
8918 * We could do this even if the old and new tuple are on different pages,
8919 * but only if we don't make a full-page image of the old page, which is
8920 * difficult to know in advance. Also, if the old tuple is corrupt for
8921 * some reason, it would allow the corruption to propagate the new page,
8922 * so it seems best to avoid. Under the general assumption that most
8923 * updates tend to create the new tuple version on the same page, there
8924 * isn't much to be gained by doing this across pages anyway.
8925 *
8926 * Skip this if we're taking a full-page image of the new page, as we
8927 * don't include the new tuple in the WAL record in that case. Also
8928 * disable if effective_wal_level='logical', as logical decoding needs to
8929 * be able to read the new tuple in whole from the WAL record alone.
8930 */
8931 if (oldbuf == newbuf && !need_tuple_data &&
8932 !XLogCheckBufferNeedsBackup(newbuf))
8933 {
8938
8939 /* Check for common prefix between old and new tuple */
8941 {
8942 if (newp[prefixlen] != oldp[prefixlen])
8943 break;
8944 }
8945
8946 /*
8947 * Storing the length of the prefix takes 2 bytes, so we need to save
8948 * at least 3 bytes or there's no point.
8949 */
8950 if (prefixlen < 3)
8951 prefixlen = 0;
8952
8953 /* Same for suffix */
8955 {
8956 if (newp[newlen - suffixlen - 1] != oldp[oldlen - suffixlen - 1])
8957 break;
8958 }
8959 if (suffixlen < 3)
8960 suffixlen = 0;
8961 }
8962
8963 /* Prepare main WAL data chain */
8964 xlrec.flags = 0;
8965 if (all_visible_cleared)
8967 if (new_all_visible_cleared)
8969 if (prefixlen > 0)
8971 if (suffixlen > 0)
8973 if (need_tuple_data)
8974 {
8976 if (old_key_tuple)
8977 {
8980 else
8982 }
8983 }
8984
8985 /* If new tuple is the single and first tuple on page... */
8988 {
8989 info |= XLOG_HEAP_INIT_PAGE;
8991 }
8992 else
8994
8995 /* Prepare WAL data for the old page */
9000
9001 /* Prepare WAL data for the new page */
9004
9005 bufflags = REGBUF_STANDARD;
9007 bufflags |= REGBUF_WILL_INIT;
9008 if (need_tuple_data)
9009 bufflags |= REGBUF_KEEP_DATA;
9010
9011 XLogRegisterBuffer(0, newbuf, bufflags);
9012 if (oldbuf != newbuf)
9014
9016
9017 /*
9018 * Prepare WAL data for the new tuple.
9019 */
9020 if (prefixlen > 0 || suffixlen > 0)
9021 {
9022 if (prefixlen > 0 && suffixlen > 0)
9023 {
9024 prefix_suffix[0] = prefixlen;
9025 prefix_suffix[1] = suffixlen;
9027 }
9028 else if (prefixlen > 0)
9029 {
9031 }
9032 else
9033 {
9035 }
9036 }
9037
9042
9043 /*
9044 * PG73FORMAT: write bitmap [+ padding] [+ oid] + data
9045 *
9046 * The 'data' doesn't include the common prefix or suffix.
9047 */
9049 if (prefixlen == 0)
9050 {
9051 XLogRegisterBufData(0,
9054 }
9055 else
9056 {
9057 /*
9058 * Have to write the null bitmap and data after the common prefix as
9059 * two separate rdata entries.
9060 */
9061 /* bitmap [+ padding] [+ oid] */
9063 {
9064 XLogRegisterBufData(0,
9067 }
9068
9069 /* data after common prefix */
9070 XLogRegisterBufData(0,
9073 }
9074
9075 /* We need to log a tuple identity */
9076 if (need_tuple_data && old_key_tuple)
9077 {
9078 /* don't really need this, but its more comfy to decode */
9082
9084
9085 /* PG73FORMAT: write bitmap [+ padding] [+ oid] + data */
9088 }
9089
9090 /* filtering by origin on a row level is much more efficient */
9092
9093 recptr = XLogInsert(RM_HEAP_ID, info);
9094
9095 return recptr;
9096}
#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 8849 of file heapam.c.
8851{
8852 xl_heap_visible xlrec;
8853 XLogRecPtr recptr;
8854 uint8 flags;
8855
8858
8859 xlrec.snapshotConflictHorizon = snapshotConflictHorizon;
8860 xlrec.flags = vmflags;
8863 XLogBeginInsert();
8865
8866 XLogRegisterBuffer(0, vm_buffer, 0);
8867
8868 flags = REGBUF_STANDARD;
8870 flags |= REGBUF_NO_IMAGE;
8871 XLogRegisterBuffer(1, heap_buffer, flags);
8872
8874
8875 return recptr;
8876}
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 7572 of file heapam.c.
7573{
7575 MultiXactMember *members;
7576 int nmembers;
7577
7580
7581 /*
7582 * Since we know the LOCK_ONLY bit is not set, this cannot be a multi from
7583 * pre-pg_upgrade.
7584 */
7586
7587 if (nmembers > 0)
7588 {
7590
7592 {
7593 /* Ignore lockers */
7595 continue;
7596
7597 /* there can be at most one updater */
7600#ifndef USE_ASSERT_CHECKING
7601
7602 /*
7603 * in an assert-enabled build, walk the whole array to ensure
7604 * there's no other updater.
7605 */
7606 break;
7607#endif
7608 }
7609
7610 pfree(members);
7611 }
7612
7613 return update_xact;
7614}
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(), heap_lock_updated_tuple(), and HeapTupleGetUpdateXid().
◆ MultiXactIdWait()
|
static |
Definition at line 7818 of file heapam.c.
7821{
7824}
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 520 of file heapam.c.
524{
525 int ntup = 0;
526 OffsetNumber lineoff;
527
529 {
531 HeapTupleData loctup;
532 bool valid;
533
535 continue;
536
541
542 if (all_visible)
543 valid = true;
544 else
545 valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
546
547 if (check_serializable)
549 &loctup, buffer, snapshot);
550
551 if (valid)
552 {
553 scan->rs_vistuples[ntup] = lineoff;
554 ntup++;
555 }
556 }
557
559
560 return ntup;
561}
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 2068 of file heapam.c.
2069{
2073
2074 /*
2075 * Despite the name, we also reset bulk relation extension state.
2076 * Otherwise we can end up erroring out due to looking for free space in
2077 * ->next_free of one partition, even though ->next_free was set when
2078 * extending another partition. It could obviously also be bad for
2079 * efficiency to look at existing blocks at offsets from another
2080 * partition, even if we don't error out.
2081 */
2084}
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 3230 of file heapam.c.
3231{
3232 TM_Result result;
3233 TM_FailureData tmfd;
3234
3235 result = heap_delete(relation, tid,
3237 true /* wait for commit */ ,
3238 &tmfd, false /* changingPart */ );
3239 switch (result)
3240 {
3242 /* Tuple was already updated in current command? */
3244 break;
3245
3247 /* done successfully */
3248 break;
3249
3252 break;
3253
3256 break;
3257
3258 default:
3260 break;
3261 }
3262}
TM_Result heap_delete(Relation relation, const ItemPointerData *tid, CommandId cid, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart)
Definition: heapam.c:2807
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 2749 of file heapam.c.
2750{
2752}
void heap_insert(Relation relation, HeapTuple tup, CommandId cid, int options, BulkInsertState bistate)
Definition: heapam.c:2106
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 4520 of file heapam.c.
4522{
4523 TM_Result result;
4524 TM_FailureData tmfd;
4525 LockTupleMode lockmode;
4526
4527 result = heap_update(relation, otid, tup,
4529 true /* wait for commit */ ,
4530 &tmfd, &lockmode, update_indexes);
4531 switch (result)
4532 {
4534 /* Tuple was already updated in current command? */
4536 break;
4537
4539 /* done successfully */
4540 break;
4541
4544 break;
4545
4548 break;
4549
4550 default:
4552 break;
4553 }
4554}
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:3276
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 5640 of file heapam.c.
5643{
5644 MultiXactStatus wantedstatus;
5645
5646 *needwait = false;
5648
5649 /*
5650 * Note: we *must* check TransactionIdIsInProgress before
5651 * TransactionIdDidAbort/Commit; see comment at top of heapam_visibility.c
5652 * for an explanation.
5653 */
5655 {
5656 /*
5657 * The tuple has already been locked by our own transaction. This is
5658 * very rare but can happen if multiple transactions are trying to
5659 * lock an ancient version of the same tuple.
5660 */
5662 }
5664 {
5665 /*
5666 * If the locking transaction is running, what we do depends on
5667 * whether the lock modes conflict: if they do, then we must wait for
5668 * it to finish; otherwise we can fall through to lock this tuple
5669 * version without waiting.
5670 */
5672 LOCKMODE_from_mxstatus(wantedstatus)))
5673 {
5674 *needwait = true;
5675 }
5676
5677 /*
5678 * If we set needwait above, then this value doesn't matter;
5679 * otherwise, this value signals to caller that it's okay to proceed.
5680 */
5682 }
5686 {
5687 /*
5688 * The other transaction committed. If it was only a locker, then the
5689 * lock is completely gone now and we can return success; but if it
5690 * was an update, then what we do depends on whether the two lock
5691 * modes conflict. If they conflict, then we must report error to
5692 * caller. But if they don't, we can fall through to allow the current
5693 * transaction to lock the tuple.
5694 *
5695 * Note: the reason we worry about ISUPDATE here is because as soon as
5696 * a transaction ends, all its locks are gone and meaningless, and
5697 * thus we can ignore them; whereas its updates persist. In the
5698 * TransactionIdIsInProgress case, above, we don't need to check
5699 * because we know the lock is still "alive" and thus a conflict needs
5700 * always be checked.
5701 */
5704
5706 LOCKMODE_from_mxstatus(wantedstatus)))
5707 {
5708 /* bummer */
5711 else
5713 }
5714
5716 }
5717
5718 /* Not in progress, not aborted, not committed -- must have crashed */
5720}
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 2017 of file heapam.c.
2018{
2021
2023 {
2025 TransactionIdDidCommit(xid))
2027 xid);
2028 else
2030 InvalidTransactionId);
2031 }
2032}
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 2784 of file heapam.c.
2785{
2788
2789 if ((new_infomask & interesting) != (old_infomask & interesting))
2790 return true;
2791
2792 return false;
2793}
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().
