From aca32df57af1b91d2b5569a434c342d472ceb3ef Mon Sep 17 00:00:00 2001 From: Melanie Plageman Date: Tue, 11 Jun 2024 09:59:23 -0400 Subject: [PATCH v21 12/20] Update variable names in bitmap scan descriptors The previous commit which added BitmapTableScanDesc and BitmapHeapScanDesc used the existing member names from TableScanDescData and HeapScanDescData for diff clarity. This commit renames the members -- in many cases by removing the rs_ prefix which is not relevant or needed here. --- src/backend/access/heap/heapam.c | 64 ++++++++++----------- src/backend/access/heap/heapam_handler.c | 70 +++++++++++------------ src/backend/executor/nodeBitmapHeapscan.c | 14 ++--- src/include/access/heapam.h | 22 +++---- src/include/access/relscan.h | 8 +-- src/include/access/tableam.h | 14 ++--- 6 files changed, 96 insertions(+), 96 deletions(-) diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index 0d8239d2f15..88da737d149 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -1244,27 +1244,27 @@ heap_beginscan_bm(Relation relation, Snapshot snapshot, uint32 flags) RelationIncrementReferenceCount(relation); scan = (BitmapHeapScanDesc *) palloc(sizeof(BitmapHeapScanDesc)); - scan->rs_base.rs_rd = relation; - scan->rs_base.rs_snapshot = snapshot; - scan->rs_base.rs_flags = flags; + scan->base.rel = relation; + scan->base.snapshot = snapshot; + scan->base.flags = flags; Assert(snapshot && IsMVCCSnapshot(snapshot)); /* we only need to set this up once */ - scan->rs_ctup.t_tableOid = RelationGetRelid(relation); + scan->ctup.t_tableOid = RelationGetRelid(relation); - scan->rs_nblocks = RelationGetNumberOfBlocks(scan->rs_base.rs_rd); + scan->nblocks = RelationGetNumberOfBlocks(scan->base.rel); - scan->rs_ctup.t_data = NULL; - ItemPointerSetInvalid(&scan->rs_ctup.t_self); - scan->rs_cbuf = InvalidBuffer; - scan->rs_cblock = InvalidBlockNumber; + scan->ctup.t_data = NULL; + ItemPointerSetInvalid(&scan->ctup.t_self); + scan->cbuf = InvalidBuffer; + scan->cblock = InvalidBlockNumber; - scan->rs_cindex = 0; - scan->rs_ntuples = 0; + scan->vis_idx = 0; + scan->vis_ntuples = 0; - scan->rs_vmbuffer = InvalidBuffer; - scan->rs_empty_tuples_pending = 0; + scan->vmbuffer = InvalidBuffer; + scan->empty_tuples_pending = 0; return (BitmapTableScanDesc *) scan; } @@ -1274,31 +1274,31 @@ heap_rescan_bm(BitmapTableScanDesc *sscan) { BitmapHeapScanDesc *scan = (BitmapHeapScanDesc *) sscan; - if (BufferIsValid(scan->rs_cbuf)) + if (BufferIsValid(scan->cbuf)) { - ReleaseBuffer(scan->rs_cbuf); - scan->rs_cbuf = InvalidBuffer; + ReleaseBuffer(scan->cbuf); + scan->cbuf = InvalidBuffer; } - if (BufferIsValid(scan->rs_vmbuffer)) + if (BufferIsValid(scan->vmbuffer)) { - ReleaseBuffer(scan->rs_vmbuffer); - scan->rs_vmbuffer = InvalidBuffer; + ReleaseBuffer(scan->vmbuffer); + scan->vmbuffer = InvalidBuffer; } - scan->rs_cblock = InvalidBlockNumber; + scan->cblock = InvalidBlockNumber; /* - * Reset rs_empty_tuples_pending, a field only used by bitmap heap scan, - * to avoid incorrectly emitting NULL-filled tuples from a previous scan - * on rescan. + * Reset empty_tuples_pending, a field only used by bitmap heap scan, to + * avoid incorrectly emitting NULL-filled tuples from a previous scan on + * rescan. */ - scan->rs_empty_tuples_pending = 0; + scan->empty_tuples_pending = 0; - scan->rs_nblocks = RelationGetNumberOfBlocks(scan->rs_base.rs_rd); + scan->nblocks = RelationGetNumberOfBlocks(scan->base.rel); - scan->rs_ctup.t_data = NULL; - ItemPointerSetInvalid(&scan->rs_ctup.t_self); + scan->ctup.t_data = NULL; + ItemPointerSetInvalid(&scan->ctup.t_self); } void @@ -1306,16 +1306,16 @@ heap_endscan_bm(BitmapTableScanDesc *sscan) { BitmapHeapScanDesc *scan = (BitmapHeapScanDesc *) sscan; - if (BufferIsValid(scan->rs_cbuf)) - ReleaseBuffer(scan->rs_cbuf); + if (BufferIsValid(scan->cbuf)) + ReleaseBuffer(scan->cbuf); - if (BufferIsValid(scan->rs_vmbuffer)) - ReleaseBuffer(scan->rs_vmbuffer); + if (BufferIsValid(scan->vmbuffer)) + ReleaseBuffer(scan->vmbuffer); /* * decrement relation reference count and free scan descriptor storage */ - RelationDecrementReferenceCount(scan->rs_base.rs_rd); + RelationDecrementReferenceCount(scan->base.rel); pfree(scan); } diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c index 82f216952b1..4057d0cf22b 100644 --- a/src/backend/access/heap/heapam_handler.c +++ b/src/backend/access/heap/heapam_handler.c @@ -2130,8 +2130,8 @@ heapam_scan_bitmap_next_block(BitmapTableScanDesc *scan, int ntup; TBMIterateResult *tbmres; - hscan->rs_cindex = 0; - hscan->rs_ntuples = 0; + hscan->vis_idx = 0; + hscan->vis_ntuples = 0; *blockno = InvalidBlockNumber; *recheck = true; @@ -2140,7 +2140,7 @@ heapam_scan_bitmap_next_block(BitmapTableScanDesc *scan, { CHECK_FOR_INTERRUPTS(); - tbmres = tbm_iterate(&scan->tbmiterator); + tbmres = tbm_iterate(&scan->iterator); if (tbmres == NULL) return false; @@ -2153,7 +2153,7 @@ heapam_scan_bitmap_next_block(BitmapTableScanDesc *scan, * isolation though, as we need to examine all invisible tuples * reachable by the index. */ - } while (!IsolationIsSerializable() && tbmres->blockno >= hscan->rs_nblocks); + } while (!IsolationIsSerializable() && tbmres->blockno >= hscan->nblocks); /* Got a valid block */ *blockno = tbmres->blockno; @@ -2164,15 +2164,15 @@ heapam_scan_bitmap_next_block(BitmapTableScanDesc *scan, * heap, the bitmap entries don't need rechecking, and all tuples on the * page are visible to our transaction. */ - if (!(scan->rs_flags & SO_NEED_TUPLES) && + if (!(scan->flags & SO_NEED_TUPLES) && !tbmres->recheck && - VM_ALL_VISIBLE(scan->rs_rd, tbmres->blockno, &hscan->rs_vmbuffer)) + VM_ALL_VISIBLE(scan->rel, tbmres->blockno, &hscan->vmbuffer)) { /* can't be lossy in the skip_fetch case */ Assert(tbmres->ntuples >= 0); - Assert(hscan->rs_empty_tuples_pending >= 0); + Assert(hscan->empty_tuples_pending >= 0); - hscan->rs_empty_tuples_pending += tbmres->ntuples; + hscan->empty_tuples_pending += tbmres->ntuples; return true; } @@ -2182,19 +2182,19 @@ heapam_scan_bitmap_next_block(BitmapTableScanDesc *scan, /* * Acquire pin on the target heap page, trading in any pin we held before. */ - hscan->rs_cbuf = ReleaseAndReadBuffer(hscan->rs_cbuf, - scan->rs_rd, - block); - hscan->rs_cblock = block; - buffer = hscan->rs_cbuf; - snapshot = scan->rs_snapshot; + hscan->cbuf = ReleaseAndReadBuffer(hscan->cbuf, + scan->rel, + block); + hscan->cblock = block; + buffer = hscan->cbuf; + snapshot = scan->snapshot; ntup = 0; /* * Prune and repair fragmentation for the whole page, if possible. */ - heap_page_prune_opt(scan->rs_rd, buffer); + heap_page_prune_opt(scan->rel, buffer); /* * We must hold share lock on the buffer content while examining tuple @@ -2222,9 +2222,9 @@ heapam_scan_bitmap_next_block(BitmapTableScanDesc *scan, HeapTupleData heapTuple; ItemPointerSet(&tid, block, offnum); - if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot, + if (heap_hot_search_buffer(&tid, scan->rel, buffer, snapshot, &heapTuple, NULL, true)) - hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid); + hscan->vis_tuples[ntup++] = ItemPointerGetOffsetNumber(&tid); } } else @@ -2248,16 +2248,16 @@ heapam_scan_bitmap_next_block(BitmapTableScanDesc *scan, continue; loctup.t_data = (HeapTupleHeader) PageGetItem(page, lp); loctup.t_len = ItemIdGetLength(lp); - loctup.t_tableOid = scan->rs_rd->rd_id; + loctup.t_tableOid = scan->rel->rd_id; ItemPointerSet(&loctup.t_self, block, offnum); valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer); if (valid) { - hscan->rs_vistuples[ntup++] = offnum; - PredicateLockTID(scan->rs_rd, &loctup.t_self, snapshot, + hscan->vis_tuples[ntup++] = offnum; + PredicateLockTID(scan->rel, &loctup.t_self, snapshot, HeapTupleHeaderGetXmin(loctup.t_data)); } - HeapCheckForSerializableConflictOut(valid, scan->rs_rd, &loctup, + HeapCheckForSerializableConflictOut(valid, scan->rel, &loctup, buffer, snapshot); } } @@ -2265,7 +2265,7 @@ heapam_scan_bitmap_next_block(BitmapTableScanDesc *scan, LockBuffer(buffer, BUFFER_LOCK_UNLOCK); Assert(ntup <= MaxHeapTuplesPerPage); - hscan->rs_ntuples = ntup; + hscan->vis_ntuples = ntup; if (tbmres->ntuples < 0) (*lossy_pages)++; @@ -2291,43 +2291,43 @@ heapam_scan_bitmap_next_tuple(BitmapTableScanDesc *scan, Page page; ItemId lp; - if (hscan->rs_empty_tuples_pending > 0) + if (hscan->empty_tuples_pending > 0) { /* * If we don't have to fetch the tuple, just return nulls. */ ExecStoreAllNullTuple(slot); - hscan->rs_empty_tuples_pending--; + hscan->empty_tuples_pending--; return true; } /* * Out of range? If so, nothing more to look at on this page */ - if (hscan->rs_cindex < 0 || hscan->rs_cindex >= hscan->rs_ntuples) + if (hscan->vis_idx < 0 || hscan->vis_idx >= hscan->vis_ntuples) return false; - targoffset = hscan->rs_vistuples[hscan->rs_cindex]; - page = BufferGetPage(hscan->rs_cbuf); + targoffset = hscan->vis_tuples[hscan->vis_idx]; + page = BufferGetPage(hscan->cbuf); lp = PageGetItemId(page, targoffset); Assert(ItemIdIsNormal(lp)); - hscan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem(page, lp); - hscan->rs_ctup.t_len = ItemIdGetLength(lp); - hscan->rs_ctup.t_tableOid = scan->rs_rd->rd_id; - ItemPointerSet(&hscan->rs_ctup.t_self, hscan->rs_cblock, targoffset); + hscan->ctup.t_data = (HeapTupleHeader) PageGetItem(page, lp); + hscan->ctup.t_len = ItemIdGetLength(lp); + hscan->ctup.t_tableOid = scan->rel->rd_id; + ItemPointerSet(&hscan->ctup.t_self, hscan->cblock, targoffset); - pgstat_count_heap_fetch(scan->rs_rd); + pgstat_count_heap_fetch(scan->rel); /* * Set up the result slot to point to this tuple. Note that the slot * acquires a pin on the buffer. */ - ExecStoreBufferHeapTuple(&hscan->rs_ctup, + ExecStoreBufferHeapTuple(&hscan->ctup, slot, - hscan->rs_cbuf); + hscan->cbuf); - hscan->rs_cindex++; + hscan->vis_idx++; return true; } diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 84c720bdc76..5f625c1f3e6 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -166,11 +166,11 @@ BitmapHeapNext(BitmapHeapScanState *node) else { /* rescan to release any page pin */ - tbm_end_iterate(&scan->tbmiterator); + tbm_end_iterate(&scan->iterator); table_rescan_bm(scan, dsa, node->prefetch_maximum); } - tbm_begin_iterate(&scan->tbmiterator, node->tbm, dsa, + tbm_begin_iterate(&scan->iterator, node->tbm, dsa, pstate ? pstate->tbmiterator : InvalidDsaPointer); @@ -436,14 +436,14 @@ BitmapPrefetch(BitmapHeapScanState *node, BitmapTableScanDesc *scan) * logic normally. (Would it be better not to increment * prefetch_pages?) */ - skip_fetch = (!(scan->rs_flags & SO_NEED_TUPLES) && + skip_fetch = (!(scan->flags & SO_NEED_TUPLES) && !tbmpre->recheck && VM_ALL_VISIBLE(node->ss.ss_currentRelation, tbmpre->blockno, &node->pvmbuffer)); if (!skip_fetch) - PrefetchBuffer(scan->rs_rd, MAIN_FORKNUM, tbmpre->blockno); + PrefetchBuffer(scan->rel, MAIN_FORKNUM, tbmpre->blockno); } } @@ -488,14 +488,14 @@ BitmapPrefetch(BitmapHeapScanState *node, BitmapTableScanDesc *scan) node->pfblockno = tbmpre->blockno; /* As above, skip prefetch if we expect not to need page */ - skip_fetch = (!(scan->rs_flags & SO_NEED_TUPLES) && + skip_fetch = (!(scan->flags & SO_NEED_TUPLES) && !tbmpre->recheck && VM_ALL_VISIBLE(node->ss.ss_currentRelation, tbmpre->blockno, &node->pvmbuffer)); if (!skip_fetch) - PrefetchBuffer(scan->rs_rd, MAIN_FORKNUM, tbmpre->blockno); + PrefetchBuffer(scan->rel, MAIN_FORKNUM, tbmpre->blockno); } } } @@ -594,7 +594,7 @@ ExecEndBitmapHeapScan(BitmapHeapScanState *node) */ if (scanDesc) { - tbm_end_iterate(&scanDesc->tbmiterator); + tbm_end_iterate(&scanDesc->iterator); table_endscan_bm(scanDesc); } diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 3cac199dd36..1d5583cac22 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -100,19 +100,19 @@ typedef struct HeapScanDescData *HeapScanDesc; typedef struct BitmapHeapScanDesc { - BitmapTableScanDesc rs_base; + BitmapTableScanDesc base; - BlockNumber rs_nblocks; /* total number of blocks in rel */ + BlockNumber nblocks; /* total number of blocks in rel */ - int rs_cindex; /* current tuple's index in vistuples */ - int rs_ntuples; /* number of visible tuples on page */ - OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]; /* their offsets */ + int vis_idx; /* current tuple's index in vistuples */ + int vis_ntuples; /* number of visible tuples on page */ + OffsetNumber vis_tuples[MaxHeapTuplesPerPage]; /* their offsets */ - Buffer rs_cbuf; /* current buffer in scan, if any */ - /* NB: if rs_cbuf is not InvalidBuffer, we hold a pin on that buffer */ - HeapTupleData rs_ctup; /* current tuple in scan, if any */ + Buffer cbuf; /* current buffer in scan, if any */ + /* NB: if cbuf is not InvalidBuffer, we hold a pin on that buffer */ + HeapTupleData ctup; /* current tuple in scan, if any */ - BlockNumber rs_cblock; /* current block # in scan, if any */ + BlockNumber cblock; /* current block # in scan, if any */ /* * These fields are only used for bitmap scans for the "skip fetch" @@ -121,8 +121,8 @@ typedef struct BitmapHeapScanDesc * block reported by the bitmap to determine how many NULL-filled tuples * to return. They are common to parallel and serial BitmapHeapScans */ - Buffer rs_vmbuffer; - int rs_empty_tuples_pending; + Buffer vmbuffer; + int empty_tuples_pending; } BitmapHeapScanDesc; /* diff --git a/src/include/access/relscan.h b/src/include/access/relscan.h index 036ef29e7d5..086fce35a8b 100644 --- a/src/include/access/relscan.h +++ b/src/include/access/relscan.h @@ -54,19 +54,19 @@ typedef struct TableScanDescData *TableScanDesc; typedef struct BitmapTableScanDesc { - Relation rs_rd; /* heap relation descriptor */ - struct SnapshotData *rs_snapshot; /* snapshot to see */ + Relation rel; /* heap relation descriptor */ + struct SnapshotData *snapshot; /* snapshot to see */ /* * Members common to Parallel and Serial BitmapTableScans */ - TBMIterator tbmiterator; + TBMIterator iterator; /* * Information about type and behaviour of the scan, a bitmask of members * of the ScanOptions enum (see tableam.h). */ - uint32 rs_flags; + uint32 flags; } BitmapTableScanDesc; /* diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h index 5110fa2b443..69ccdaee8c4 100644 --- a/src/include/access/tableam.h +++ b/src/include/access/tableam.h @@ -988,7 +988,7 @@ table_rescan_bm(BitmapTableScanDesc *scan, dsa_area *dsa, int prefetch_maximum) { - scan->rs_rd->rd_tableam->scan_rescan_bm(scan); + scan->rel->rd_tableam->scan_rescan_bm(scan); } /* @@ -997,7 +997,7 @@ table_rescan_bm(BitmapTableScanDesc *scan, static inline void table_endscan_bm(BitmapTableScanDesc *scan) { - scan->rs_rd->rd_tableam->scan_end_bm(scan); + scan->rel->rd_tableam->scan_end_bm(scan); } @@ -2020,9 +2020,9 @@ table_scan_bitmap_next_block(BitmapTableScanDesc *scan, if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan)) elog(ERROR, "unexpected table_scan_bitmap_next_block call during logical decoding"); - return scan->rs_rd->rd_tableam->scan_bitmap_next_block(scan, - blockno, recheck, - lossy_pages, exact_pages); + return scan->rel->rd_tableam->scan_bitmap_next_block(scan, + blockno, recheck, + lossy_pages, exact_pages); } /* @@ -2045,8 +2045,8 @@ table_scan_bitmap_next_tuple(BitmapTableScanDesc *scan, if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan)) elog(ERROR, "unexpected table_scan_bitmap_next_tuple call during logical decoding"); - return scan->rs_rd->rd_tableam->scan_bitmap_next_tuple(scan, - slot); + return scan->rel->rd_tableam->scan_bitmap_next_tuple(scan, + slot); } /* -- 2.34.1