#include "access/brin_revmap.h"

Include dependency graph for brin_pageops.h:

This graph shows which files directly or indirectly include this file:

Functions
bool	brin_doupdate (Relation idxrel, BlockNumber pagesPerRange, BrinRevmap revmap, BlockNumber heapBlk, Buffer oldbuf, OffsetNumber oldoff, const BrinTuple origtup, Size origsz, const BrinTuple *newtup, Size newsz, bool samepage)

bool	brin_can_do_samepage_update (Buffer buffer, Size origsz, Size newsz)

OffsetNumber	brin_doinsert (Relation idxrel, BlockNumber pagesPerRange, BrinRevmap revmap, Buffer buffer, BlockNumber heapBlk, BrinTuple *tup, Size itemsz)

void	brin_page_init (Page page, uint16 type)

void	brin_metapage_init (Page page, BlockNumber pagesPerRange, uint16 version)

bool	brin_start_evacuating_page (Relation idxRel, Buffer buf)

void	brin_evacuate_page (Relation idxRel, BlockNumber pagesPerRange, BrinRevmap *revmap, Buffer buf)

void	brin_page_cleanup (Relation idxrel, Buffer buf)

Function Documentation

◆ brin_can_do_samepage_update()

bool brin_can_do_samepage_update	(	Buffer	buffer,
		Size	origsz,
		Size	newsz
	)

Definition at line 324 of file brin_pageops.c.

 {
     return
         ((newsz <= origsz) ||
          PageGetExactFreeSpace(BufferGetPage(buffer)) >= (newsz - origsz));
 }

References BufferGetPage(), and PageGetExactFreeSpace().

Referenced by brin_doupdate(), brininsert(), and summarize_range().

◆ brin_doinsert()

OffsetNumber brin_doinsert	(	Relation	idxrel,
		BlockNumber	pagesPerRange,
		BrinRevmap *	revmap,
		Buffer *	buffer,
		BlockNumber	heapBlk,
		BrinTuple *	tup,
		Size	itemsz
	)

Definition at line 343 of file brin_pageops.c.

 {
     Page        page;
     BlockNumber blk;
     OffsetNumber off;
     Size        freespace = 0;
     Buffer      revmapbuf;
     ItemPointerData tid;
     bool        extended;
  
     Assert(itemsz == MAXALIGN(itemsz));
  
     /* If the item is oversized, don't even bother. */
     if (itemsz > BrinMaxItemSize)
     {
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("index row size %zu exceeds maximum %zu for index \"%s\"",
                         itemsz, BrinMaxItemSize, RelationGetRelationName(idxrel))));
         return InvalidOffsetNumber; /* keep compiler quiet */
     }
  
     /* Make sure the revmap is long enough to contain the entry we need */
     brinRevmapExtend(revmap, heapBlk);
  
     /*
      * Acquire lock on buffer supplied by caller, if any.  If it doesn't have
      * enough space, unpin it to obtain a new one below.
      */
     if (BufferIsValid(*buffer))
     {
         /*
          * It's possible that another backend (or ourselves!) extended the
          * revmap over the page we held a pin on, so we cannot assume that
          * it's still a regular page.
          */
         LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
         if (br_page_get_freespace(BufferGetPage(*buffer)) < itemsz)
         {
             UnlockReleaseBuffer(*buffer);
             *buffer = InvalidBuffer;
         }
     }
  
     /*
      * If we still don't have a usable buffer, have brin_getinsertbuffer
      * obtain one for us.
      */
     if (!BufferIsValid(*buffer))
     {
         do
             *buffer = brin_getinsertbuffer(idxrel, InvalidBuffer, itemsz, &extended);
         while (!BufferIsValid(*buffer));
     }
     else
         extended = false;
  
     /* Now obtain lock on revmap buffer */
     revmapbuf = brinLockRevmapPageForUpdate(revmap, heapBlk);
  
     page = BufferGetPage(*buffer);
     blk = BufferGetBlockNumber(*buffer);
  
     /* Execute the actual insertion */
     START_CRIT_SECTION();
     if (extended)
         brin_page_init(page, BRIN_PAGETYPE_REGULAR);
     off = PageAddItem(page, (Item) tup, itemsz, InvalidOffsetNumber,
                       false, false);
     if (off == InvalidOffsetNumber)
         elog(ERROR, "failed to add BRIN tuple to new page");
     MarkBufferDirty(*buffer);
  
     /* needed to update FSM below */
     if (extended)
         freespace = br_page_get_freespace(page);
  
     ItemPointerSet(&tid, blk, off);
     brinSetHeapBlockItemptr(revmapbuf, pagesPerRange, heapBlk, tid);
     MarkBufferDirty(revmapbuf);
  
     /* XLOG stuff */
     if (RelationNeedsWAL(idxrel))
     {
         xl_brin_insert xlrec;
         XLogRecPtr  recptr;
         uint8       info;
  
         info = XLOG_BRIN_INSERT | (extended ? XLOG_BRIN_INIT_PAGE : 0);
         xlrec.heapBlk = heapBlk;
         xlrec.pagesPerRange = pagesPerRange;
         xlrec.offnum = off;
  
         XLogBeginInsert();
         XLogRegisterData((char *) &xlrec, SizeOfBrinInsert);
  
         XLogRegisterBuffer(0, *buffer, REGBUF_STANDARD | (extended ? REGBUF_WILL_INIT : 0));
         XLogRegisterBufData(0, (char *) tup, itemsz);
  
         XLogRegisterBuffer(1, revmapbuf, 0);
  
         recptr = XLogInsert(RM_BRIN_ID, info);
  
         PageSetLSN(page, recptr);
         PageSetLSN(BufferGetPage(revmapbuf), recptr);
     }
  
     END_CRIT_SECTION();
  
     /* Tuple is firmly on buffer; we can release our locks */
     LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
     LockBuffer(revmapbuf, BUFFER_LOCK_UNLOCK);
  
     BRIN_elog((DEBUG2, "inserted tuple (%u,%u) for range starting at %u",
                blk, off, heapBlk));
  
     if (extended)
     {
         RecordPageWithFreeSpace(idxrel, blk, freespace);
         FreeSpaceMapVacuumRange(idxrel, blk, blk + 1);
     }
  
     return off;
 }

References Assert(), br_page_get_freespace(), BRIN_elog, brin_getinsertbuffer(), brin_page_init(), BRIN_PAGETYPE_REGULAR, brinLockRevmapPageForUpdate(), BrinMaxItemSize, brinRevmapExtend(), brinSetHeapBlockItemptr(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), DEBUG2, elog(), END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, FreeSpaceMapVacuumRange(), xl_brin_insert::heapBlk, InvalidBuffer, InvalidOffsetNumber, ItemPointerSet(), LockBuffer(), MarkBufferDirty(), MAXALIGN, xl_brin_insert::offnum, PageAddItem, PageSetLSN(), xl_brin_insert::pagesPerRange, RecordPageWithFreeSpace(), REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetRelationName, RelationNeedsWAL, SizeOfBrinInsert, START_CRIT_SECTION, UnlockReleaseBuffer(), XLOG_BRIN_INIT_PAGE, XLOG_BRIN_INSERT, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by form_and_insert_tuple(), and summarize_range().

◆ brin_doupdate()

bool brin_doupdate	(	Relation	idxrel,
		BlockNumber	pagesPerRange,
		BrinRevmap *	revmap,
		BlockNumber	heapBlk,
		Buffer	oldbuf,
		OffsetNumber	oldoff,
		const BrinTuple *	origtup,
		Size	origsz,
		const BrinTuple *	newtup,
		Size	newsz,
		bool	samepage
	)

Definition at line 54 of file brin_pageops.c.

 {
     Page        oldpage;
     ItemId      oldlp;
     BrinTuple  *oldtup;
     Size        oldsz;
     Buffer      newbuf;
     BlockNumber newblk = InvalidBlockNumber;
     bool        extended;
  
     Assert(newsz == MAXALIGN(newsz));
  
     /* If the item is oversized, don't bother. */
     if (newsz > BrinMaxItemSize)
     {
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("index row size %zu exceeds maximum %zu for index \"%s\"",
                         newsz, BrinMaxItemSize, RelationGetRelationName(idxrel))));
         return false;           /* keep compiler quiet */
     }
  
     /* make sure the revmap is long enough to contain the entry we need */
     brinRevmapExtend(revmap, heapBlk);
  
     if (!samepage)
     {
         /* need a page on which to put the item */
         newbuf = brin_getinsertbuffer(idxrel, oldbuf, newsz, &extended);
         if (!BufferIsValid(newbuf))
         {
             Assert(!extended);
             return false;
         }
  
         /*
          * Note: it's possible (though unlikely) that the returned newbuf is
          * the same as oldbuf, if brin_getinsertbuffer determined that the old
          * buffer does in fact have enough space.
          */
         if (newbuf == oldbuf)
         {
             Assert(!extended);
             newbuf = InvalidBuffer;
         }
         else
             newblk = BufferGetBlockNumber(newbuf);
     }
     else
     {
         LockBuffer(oldbuf, BUFFER_LOCK_EXCLUSIVE);
         newbuf = InvalidBuffer;
         extended = false;
     }
     oldpage = BufferGetPage(oldbuf);
     oldlp = PageGetItemId(oldpage, oldoff);
  
     /*
      * Check that the old tuple wasn't updated concurrently: it might have
      * moved someplace else entirely, and for that matter the whole page
      * might've become a revmap page.  Note that in the first two cases
      * checked here, the "oldlp" we just calculated is garbage; but
      * PageGetItemId() is simple enough that it was safe to do that
      * calculation anyway.
      */
     if (!BRIN_IS_REGULAR_PAGE(oldpage) ||
         oldoff > PageGetMaxOffsetNumber(oldpage) ||
         !ItemIdIsNormal(oldlp))
     {
         LockBuffer(oldbuf, BUFFER_LOCK_UNLOCK);
  
         /*
          * If this happens, and the new buffer was obtained by extending the
          * relation, then we need to ensure we don't leave it uninitialized or
          * forget about it.
          */
         if (BufferIsValid(newbuf))
         {
             if (extended)
                 brin_initialize_empty_new_buffer(idxrel, newbuf);
             UnlockReleaseBuffer(newbuf);
             if (extended)
                 FreeSpaceMapVacuumRange(idxrel, newblk, newblk + 1);
         }
         return false;
     }
  
     oldsz = ItemIdGetLength(oldlp);
     oldtup = (BrinTuple *) PageGetItem(oldpage, oldlp);
  
     /*
      * ... or it might have been updated in place to different contents.
      */
     if (!brin_tuples_equal(oldtup, oldsz, origtup, origsz))
     {
         LockBuffer(oldbuf, BUFFER_LOCK_UNLOCK);
         if (BufferIsValid(newbuf))
         {
             /* As above, initialize and record new page if we got one */
             if (extended)
                 brin_initialize_empty_new_buffer(idxrel, newbuf);
             UnlockReleaseBuffer(newbuf);
             if (extended)
                 FreeSpaceMapVacuumRange(idxrel, newblk, newblk + 1);
         }
         return false;
     }
  
     /*
      * Great, the old tuple is intact.  We can proceed with the update.
      *
      * If there's enough room in the old page for the new tuple, replace it.
      *
      * Note that there might now be enough space on the page even though the
      * caller told us there isn't, if a concurrent update moved another tuple
      * elsewhere or replaced a tuple with a smaller one.
      */
     if (((BrinPageFlags(oldpage) & BRIN_EVACUATE_PAGE) == 0) &&
         brin_can_do_samepage_update(oldbuf, origsz, newsz))
     {
         START_CRIT_SECTION();
         if (!PageIndexTupleOverwrite(oldpage, oldoff, (Item) unconstify(BrinTuple *, newtup), newsz))
             elog(ERROR, "failed to replace BRIN tuple");
         MarkBufferDirty(oldbuf);
  
         /* XLOG stuff */
         if (RelationNeedsWAL(idxrel))
         {
             xl_brin_samepage_update xlrec;
             XLogRecPtr  recptr;
             uint8       info = XLOG_BRIN_SAMEPAGE_UPDATE;
  
             xlrec.offnum = oldoff;
  
             XLogBeginInsert();
             XLogRegisterData((char *) &xlrec, SizeOfBrinSamepageUpdate);
  
             XLogRegisterBuffer(0, oldbuf, REGBUF_STANDARD);
             XLogRegisterBufData(0, (char *) unconstify(BrinTuple *, newtup), newsz);
  
             recptr = XLogInsert(RM_BRIN_ID, info);
  
             PageSetLSN(oldpage, recptr);
         }
  
         END_CRIT_SECTION();
  
         LockBuffer(oldbuf, BUFFER_LOCK_UNLOCK);
  
         if (BufferIsValid(newbuf))
         {
             /* As above, initialize and record new page if we got one */
             if (extended)
                 brin_initialize_empty_new_buffer(idxrel, newbuf);
             UnlockReleaseBuffer(newbuf);
             if (extended)
                 FreeSpaceMapVacuumRange(idxrel, newblk, newblk + 1);
         }
  
         return true;
     }
     else if (newbuf == InvalidBuffer)
     {
         /*
          * Not enough space, but caller said that there was. Tell them to
          * start over.
          */
         LockBuffer(oldbuf, BUFFER_LOCK_UNLOCK);
         return false;
     }
     else
     {
         /*
          * Not enough free space on the oldpage. Put the new tuple on the new
          * page, and update the revmap.
          */
         Page        newpage = BufferGetPage(newbuf);
         Buffer      revmapbuf;
         ItemPointerData newtid;
         OffsetNumber newoff;
         Size        freespace = 0;
  
         revmapbuf = brinLockRevmapPageForUpdate(revmap, heapBlk);
  
         START_CRIT_SECTION();
  
         /*
          * We need to initialize the page if it's newly obtained.  Note we
          * will WAL-log the initialization as part of the update, so we don't
          * need to do that here.
          */
         if (extended)
             brin_page_init(newpage, BRIN_PAGETYPE_REGULAR);
  
         PageIndexTupleDeleteNoCompact(oldpage, oldoff);
         newoff = PageAddItem(newpage, (Item) unconstify(BrinTuple *, newtup), newsz,
                              InvalidOffsetNumber, false, false);
         if (newoff == InvalidOffsetNumber)
             elog(ERROR, "failed to add BRIN tuple to new page");
         MarkBufferDirty(oldbuf);
         MarkBufferDirty(newbuf);
  
         /* needed to update FSM below */
         if (extended)
             freespace = br_page_get_freespace(newpage);
  
         ItemPointerSet(&newtid, newblk, newoff);
         brinSetHeapBlockItemptr(revmapbuf, pagesPerRange, heapBlk, newtid);
         MarkBufferDirty(revmapbuf);
  
         /* XLOG stuff */
         if (RelationNeedsWAL(idxrel))
         {
             xl_brin_update xlrec;
             XLogRecPtr  recptr;
             uint8       info;
  
             info = XLOG_BRIN_UPDATE | (extended ? XLOG_BRIN_INIT_PAGE : 0);
  
             xlrec.insert.offnum = newoff;
             xlrec.insert.heapBlk = heapBlk;
             xlrec.insert.pagesPerRange = pagesPerRange;
             xlrec.oldOffnum = oldoff;
  
             XLogBeginInsert();
  
             /* new page */
             XLogRegisterData((char *) &xlrec, SizeOfBrinUpdate);
  
             XLogRegisterBuffer(0, newbuf, REGBUF_STANDARD | (extended ? REGBUF_WILL_INIT : 0));
             XLogRegisterBufData(0, (char *) unconstify(BrinTuple *, newtup), newsz);
  
             /* revmap page */
             XLogRegisterBuffer(1, revmapbuf, 0);
  
             /* old page */
             XLogRegisterBuffer(2, oldbuf, REGBUF_STANDARD);
  
             recptr = XLogInsert(RM_BRIN_ID, info);
  
             PageSetLSN(oldpage, recptr);
             PageSetLSN(newpage, recptr);
             PageSetLSN(BufferGetPage(revmapbuf), recptr);
         }
  
         END_CRIT_SECTION();
  
         LockBuffer(revmapbuf, BUFFER_LOCK_UNLOCK);
         LockBuffer(oldbuf, BUFFER_LOCK_UNLOCK);
         UnlockReleaseBuffer(newbuf);
  
         if (extended)
         {
             RecordPageWithFreeSpace(idxrel, newblk, freespace);
             FreeSpaceMapVacuumRange(idxrel, newblk, newblk + 1);
         }
  
         return true;
     }
 }

References Assert(), br_page_get_freespace(), brin_can_do_samepage_update(), BRIN_EVACUATE_PAGE, brin_getinsertbuffer(), brin_initialize_empty_new_buffer(), BRIN_IS_REGULAR_PAGE, brin_page_init(), BRIN_PAGETYPE_REGULAR, brin_tuples_equal(), brinLockRevmapPageForUpdate(), BrinMaxItemSize, BrinPageFlags, brinRevmapExtend(), brinSetHeapBlockItemptr(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), elog(), END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, FreeSpaceMapVacuumRange(), xl_brin_insert::heapBlk, xl_brin_update::insert, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, ItemIdGetLength, ItemIdIsNormal, ItemPointerSet(), LockBuffer(), MarkBufferDirty(), MAXALIGN, xl_brin_insert::offnum, xl_brin_samepage_update::offnum, xl_brin_update::oldOffnum, PageAddItem, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageIndexTupleDeleteNoCompact(), PageIndexTupleOverwrite(), PageSetLSN(), xl_brin_insert::pagesPerRange, RecordPageWithFreeSpace(), REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetRelationName, RelationNeedsWAL, SizeOfBrinSamepageUpdate, SizeOfBrinUpdate, START_CRIT_SECTION, unconstify, UnlockReleaseBuffer(), XLOG_BRIN_INIT_PAGE, XLOG_BRIN_SAMEPAGE_UPDATE, XLOG_BRIN_UPDATE, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by brin_evacuate_page(), brininsert(), and summarize_range().

◆ brin_evacuate_page()

void brin_evacuate_page	(	Relation	idxRel,
		BlockNumber	pagesPerRange,
		BrinRevmap *	revmap,
		Buffer	buf
	)

Definition at line 565 of file brin_pageops.c.

 {
     OffsetNumber off;
     OffsetNumber maxoff;
     Page        page;
     BrinTuple  *btup = NULL;
     Size        btupsz = 0;
  
     page = BufferGetPage(buf);
  
     Assert(BrinPageFlags(page) & BRIN_EVACUATE_PAGE);
  
     maxoff = PageGetMaxOffsetNumber(page);
     for (off = FirstOffsetNumber; off <= maxoff; off++)
     {
         BrinTuple  *tup;
         Size        sz;
         ItemId      lp;
  
         CHECK_FOR_INTERRUPTS();
  
         lp = PageGetItemId(page, off);
         if (ItemIdIsUsed(lp))
         {
             sz = ItemIdGetLength(lp);
             tup = (BrinTuple *) PageGetItem(page, lp);
             tup = brin_copy_tuple(tup, sz, btup, &btupsz);
  
             LockBuffer(buf, BUFFER_LOCK_UNLOCK);
  
             if (!brin_doupdate(idxRel, pagesPerRange, revmap, tup->bt_blkno,
                                buf, off, tup, sz, tup, sz, false))
                 off--;          /* retry */
  
             LockBuffer(buf, BUFFER_LOCK_SHARE);
  
             /* It's possible that someone extended the revmap over this page */
             if (!BRIN_IS_REGULAR_PAGE(page))
                 break;
         }
     }
  
     UnlockReleaseBuffer(buf);
 }

References Assert(), brin_copy_tuple(), brin_doupdate(), BRIN_EVACUATE_PAGE, BRIN_IS_REGULAR_PAGE, BrinPageFlags, BrinTuple::bt_blkno, buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage(), CHECK_FOR_INTERRUPTS, FirstOffsetNumber, ItemIdGetLength, ItemIdIsUsed, LockBuffer(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), and UnlockReleaseBuffer().

Referenced by revmap_physical_extend().

◆ brin_metapage_init()

void brin_metapage_init	(	Page	page,
		BlockNumber	pagesPerRange,
		uint16	version
	)

Definition at line 487 of file brin_pageops.c.

 {
     BrinMetaPageData *metadata;
  
     brin_page_init(page, BRIN_PAGETYPE_META);
  
     metadata = (BrinMetaPageData *) PageGetContents(page);
  
     metadata->brinMagic = BRIN_META_MAGIC;
     metadata->brinVersion = version;
     metadata->pagesPerRange = pagesPerRange;
  
     /*
      * Note we cheat here a little.  0 is not a valid revmap block number
      * (because it's the metapage buffer), but doing this enables the first
      * revmap page to be created when the index is.
      */
     metadata->lastRevmapPage = 0;
  
     /*
      * Set pd_lower just past the end of the metadata.  This is essential,
      * because without doing so, metadata will be lost if xlog.c compresses
      * the page.
      */
     ((PageHeader) page)->pd_lower =
         ((char *) metadata + sizeof(BrinMetaPageData)) - (char *) page;
 }

References BRIN_META_MAGIC, brin_page_init(), BRIN_PAGETYPE_META, BrinMetaPageData::brinMagic, BrinMetaPageData::brinVersion, BrinMetaPageData::lastRevmapPage, PageGetContents(), and BrinMetaPageData::pagesPerRange.

Referenced by brin_xlog_createidx(), brinbuild(), and brinbuildempty().

◆ brin_page_cleanup()

void brin_page_cleanup	(	Relation	idxrel,
		Buffer	buf
	)

Definition at line 625 of file brin_pageops.c.

 {
     Page        page = BufferGetPage(buf);
  
     /*
      * If a page was left uninitialized, initialize it now; also record it in
      * FSM.
      *
      * Somebody else might be extending the relation concurrently.  To avoid
      * re-initializing the page before they can grab the buffer lock, we
      * acquire the extension lock momentarily.  Since they hold the extension
      * lock from before getting the page and after its been initialized, we're
      * sure to see their initialization.
      */
     if (PageIsNew(page))
     {
         LockRelationForExtension(idxrel, ShareLock);
         UnlockRelationForExtension(idxrel, ShareLock);
  
         LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
         if (PageIsNew(page))
         {
             brin_initialize_empty_new_buffer(idxrel, buf);
             LockBuffer(buf, BUFFER_LOCK_UNLOCK);
             return;
         }
         LockBuffer(buf, BUFFER_LOCK_UNLOCK);
     }
  
     /* Nothing to be done for non-regular index pages */
     if (BRIN_IS_META_PAGE(BufferGetPage(buf)) ||
         BRIN_IS_REVMAP_PAGE(BufferGetPage(buf)))
         return;
  
     /* Measure free space and record it */
     RecordPageWithFreeSpace(idxrel, BufferGetBlockNumber(buf),
                             br_page_get_freespace(page));
 }

References br_page_get_freespace(), brin_initialize_empty_new_buffer(), BRIN_IS_META_PAGE, BRIN_IS_REVMAP_PAGE, buf, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), LockBuffer(), LockRelationForExtension(), PageIsNew(), RecordPageWithFreeSpace(), ShareLock, and UnlockRelationForExtension().

Referenced by brin_vacuum_scan().

◆ brin_page_init()

void brin_page_init	(	Page	page,
		uint16	type
	)

Definition at line 476 of file brin_pageops.c.

 {
     PageInit(page, BLCKSZ, sizeof(BrinSpecialSpace));
  
     BrinPageType(page) = type;
 }

References BrinPageType, PageInit(), and generate_unaccent_rules::type.

Referenced by brin_doinsert(), brin_doupdate(), brin_initialize_empty_new_buffer(), brin_metapage_init(), brin_xlog_insert_update(), brin_xlog_revmap_extend(), and revmap_physical_extend().

◆ brin_start_evacuating_page()

bool brin_start_evacuating_page	(	Relation	idxRel,
		Buffer	buf
	)

Definition at line 525 of file brin_pageops.c.

 {
     OffsetNumber off;
     OffsetNumber maxoff;
     Page        page;
  
     page = BufferGetPage(buf);
  
     if (PageIsNew(page))
         return false;
  
     maxoff = PageGetMaxOffsetNumber(page);
     for (off = FirstOffsetNumber; off <= maxoff; off++)
     {
         ItemId      lp;
  
         lp = PageGetItemId(page, off);
         if (ItemIdIsUsed(lp))
         {
             /*
              * Prevent other backends from adding more stuff to this page:
              * BRIN_EVACUATE_PAGE informs br_page_get_freespace that this page
              * can no longer be used to add new tuples.  Note that this flag
              * is not WAL-logged, except accidentally.
              */
             BrinPageFlags(page) |= BRIN_EVACUATE_PAGE;
             MarkBufferDirtyHint(buf, true);
  
             return true;
         }
     }
     return false;
 }

References BRIN_EVACUATE_PAGE, BrinPageFlags, buf, BufferGetPage(), FirstOffsetNumber, ItemIdIsUsed, MarkBufferDirtyHint(), PageGetItemId(), PageGetMaxOffsetNumber(), and PageIsNew().