LCOV - code coverage report
Current view: top level - src/backend/access/gist - gistvacuum.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 179 205 87.3 %
Date: 2025-04-22 08:15:34 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * gistvacuum.c
       4             :  *    vacuuming routines for the postgres GiST index access method.
       5             :  *
       6             :  *
       7             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/access/gist/gistvacuum.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/genam.h"
      18             : #include "access/gist_private.h"
      19             : #include "access/transam.h"
      20             : #include "commands/vacuum.h"
      21             : #include "lib/integerset.h"
      22             : #include "miscadmin.h"
      23             : #include "storage/indexfsm.h"
      24             : #include "storage/lmgr.h"
      25             : #include "storage/read_stream.h"
      26             : #include "utils/memutils.h"
      27             : 
      28             : /* Working state needed by gistbulkdelete */
      29             : typedef struct
      30             : {
      31             :     IndexVacuumInfo *info;
      32             :     IndexBulkDeleteResult *stats;
      33             :     IndexBulkDeleteCallback callback;
      34             :     void       *callback_state;
      35             :     GistNSN     startNSN;
      36             : 
      37             :     /*
      38             :      * These are used to memorize all internal and empty leaf pages.  They are
      39             :      * used for deleting all the empty pages.
      40             :      */
      41             :     IntegerSet *internal_page_set;
      42             :     IntegerSet *empty_leaf_set;
      43             :     MemoryContext page_set_context;
      44             : } GistVacState;
      45             : 
      46             : static void gistvacuumscan(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
      47             :                            IndexBulkDeleteCallback callback, void *callback_state);
      48             : static void gistvacuumpage(GistVacState *vstate, Buffer buffer);
      49             : static void gistvacuum_delete_empty_pages(IndexVacuumInfo *info,
      50             :                                           GistVacState *vstate);
      51             : static bool gistdeletepage(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
      52             :                            Buffer parentBuffer, OffsetNumber downlink,
      53             :                            Buffer leafBuffer);
      54             : 
      55             : /*
      56             :  * VACUUM bulkdelete stage: remove index entries.
      57             :  */
      58             : IndexBulkDeleteResult *
      59          40 : gistbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
      60             :                IndexBulkDeleteCallback callback, void *callback_state)
      61             : {
      62             :     /* allocate stats if first time through, else re-use existing struct */
      63          40 :     if (stats == NULL)
      64          40 :         stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
      65             : 
      66          40 :     gistvacuumscan(info, stats, callback, callback_state);
      67             : 
      68          40 :     return stats;
      69             : }
      70             : 
      71             : /*
      72             :  * VACUUM cleanup stage: delete empty pages, and update index statistics.
      73             :  */
      74             : IndexBulkDeleteResult *
      75          82 : gistvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
      76             : {
      77             :     /* No-op in ANALYZE ONLY mode */
      78          82 :     if (info->analyze_only)
      79          16 :         return stats;
      80             : 
      81             :     /*
      82             :      * If gistbulkdelete was called, we need not do anything, just return the
      83             :      * stats from the latest gistbulkdelete call.  If it wasn't called, we
      84             :      * still need to do a pass over the index, to obtain index statistics.
      85             :      */
      86          66 :     if (stats == NULL)
      87             :     {
      88          44 :         stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
      89          44 :         gistvacuumscan(info, stats, NULL, NULL);
      90             :     }
      91             : 
      92             :     /*
      93             :      * It's quite possible for us to be fooled by concurrent page splits into
      94             :      * double-counting some index tuples, so disbelieve any total that exceeds
      95             :      * the underlying heap's count ... if we know that accurately.  Otherwise
      96             :      * this might just make matters worse.
      97             :      */
      98          66 :     if (!info->estimated_count)
      99             :     {
     100          66 :         if (stats->num_index_tuples > info->num_heap_tuples)
     101           0 :             stats->num_index_tuples = info->num_heap_tuples;
     102             :     }
     103             : 
     104          66 :     return stats;
     105             : }
     106             : 
     107             : /*
     108             :  * gistvacuumscan --- scan the index for VACUUMing purposes
     109             :  *
     110             :  * This scans the index for leaf tuples that are deletable according to the
     111             :  * vacuum callback, and updates the stats.  Both btbulkdelete and
     112             :  * btvacuumcleanup invoke this (the latter only if no btbulkdelete call
     113             :  * occurred).
     114             :  *
     115             :  * This also makes note of any empty leaf pages, as well as all internal
     116             :  * pages while looping over all index pages.  After scanning all the pages, we
     117             :  * remove the empty pages so that they can be reused.  Any deleted pages are
     118             :  * added directly to the free space map.  (They should've been added there
     119             :  * when they were originally deleted, already, but it's possible that the FSM
     120             :  * was lost at a crash, for example.)
     121             :  *
     122             :  * The caller is responsible for initially allocating/zeroing a stats struct.
     123             :  */
     124             : static void
     125          84 : gistvacuumscan(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
     126             :                IndexBulkDeleteCallback callback, void *callback_state)
     127             : {
     128          84 :     Relation    rel = info->index;
     129             :     GistVacState vstate;
     130             :     BlockNumber num_pages;
     131             :     bool        needLock;
     132             :     MemoryContext oldctx;
     133             :     BlockRangeReadStreamPrivate p;
     134          84 :     ReadStream *stream = NULL;
     135             : 
     136             :     /*
     137             :      * Reset fields that track information about the entire index now.  This
     138             :      * avoids double-counting in the case where a single VACUUM command
     139             :      * requires multiple scans of the index.
     140             :      *
     141             :      * Avoid resetting the tuples_removed and pages_newly_deleted fields here,
     142             :      * since they track information about the VACUUM command, and so must last
     143             :      * across each call to gistvacuumscan().
     144             :      *
     145             :      * (Note that pages_free is treated as state about the whole index, not
     146             :      * the current VACUUM.  This is appropriate because RecordFreeIndexPage()
     147             :      * calls are idempotent, and get repeated for the same deleted pages in
     148             :      * some scenarios.  The point for us is to track the number of recyclable
     149             :      * pages in the index at the end of the VACUUM command.)
     150             :      */
     151          84 :     stats->num_pages = 0;
     152          84 :     stats->estimated_count = false;
     153          84 :     stats->num_index_tuples = 0;
     154          84 :     stats->pages_deleted = 0;
     155          84 :     stats->pages_free = 0;
     156             : 
     157             :     /*
     158             :      * Create the integer sets to remember all the internal and the empty leaf
     159             :      * pages in page_set_context.  Internally, the integer set will remember
     160             :      * this context so that the subsequent allocations for these integer sets
     161             :      * will be done from the same context.
     162             :      *
     163             :      * XXX the allocation sizes used below pre-date generation context's block
     164             :      * growing code.  These values should likely be benchmarked and set to
     165             :      * more suitable values.
     166             :      */
     167          84 :     vstate.page_set_context = GenerationContextCreate(CurrentMemoryContext,
     168             :                                                       "GiST VACUUM page set context",
     169             :                                                       16 * 1024,
     170             :                                                       16 * 1024,
     171             :                                                       16 * 1024);
     172          84 :     oldctx = MemoryContextSwitchTo(vstate.page_set_context);
     173          84 :     vstate.internal_page_set = intset_create();
     174          84 :     vstate.empty_leaf_set = intset_create();
     175          84 :     MemoryContextSwitchTo(oldctx);
     176             : 
     177             :     /* Set up info to pass down to gistvacuumpage */
     178          84 :     vstate.info = info;
     179          84 :     vstate.stats = stats;
     180          84 :     vstate.callback = callback;
     181          84 :     vstate.callback_state = callback_state;
     182          84 :     if (RelationNeedsWAL(rel))
     183          84 :         vstate.startNSN = GetInsertRecPtr();
     184             :     else
     185           0 :         vstate.startNSN = gistGetFakeLSN(rel);
     186             : 
     187             :     /*
     188             :      * The outer loop iterates over all index pages, in physical order (we
     189             :      * hope the kernel will cooperate in providing read-ahead for speed).  It
     190             :      * is critical that we visit all leaf pages, including ones added after we
     191             :      * start the scan, else we might fail to delete some deletable tuples.
     192             :      * Hence, we must repeatedly check the relation length.  We must acquire
     193             :      * the relation-extension lock while doing so to avoid a race condition:
     194             :      * if someone else is extending the relation, there is a window where
     195             :      * bufmgr/smgr have created a new all-zero page but it hasn't yet been
     196             :      * write-locked by gistNewBuffer().  If we manage to scan such a page
     197             :      * here, we'll improperly assume it can be recycled.  Taking the lock
     198             :      * synchronizes things enough to prevent a problem: either num_pages won't
     199             :      * include the new page, or gistNewBuffer already has write lock on the
     200             :      * buffer and it will be fully initialized before we can examine it.  (See
     201             :      * also vacuumlazy.c, which has the same issue.)  Also, we need not worry
     202             :      * if a page is added immediately after we look; the page splitting code
     203             :      * already has write-lock on the left page before it adds a right page, so
     204             :      * we must already have processed any tuples due to be moved into such a
     205             :      * page.
     206             :      *
     207             :      * We can skip locking for new or temp relations, however, since no one
     208             :      * else could be accessing them.
     209             :      */
     210          84 :     needLock = !RELATION_IS_LOCAL(rel);
     211             : 
     212          84 :     p.current_blocknum = GIST_ROOT_BLKNO;
     213             : 
     214             :     /*
     215             :      * It is safe to use batchmode as block_range_read_stream_cb takes no
     216             :      * locks.
     217             :      */
     218          84 :     stream = read_stream_begin_relation(READ_STREAM_FULL |
     219             :                                         READ_STREAM_USE_BATCHING,
     220             :                                         info->strategy,
     221             :                                         rel,
     222             :                                         MAIN_FORKNUM,
     223             :                                         block_range_read_stream_cb,
     224             :                                         &p,
     225             :                                         0);
     226             :     for (;;)
     227             :     {
     228             :         /* Get the current relation length */
     229         168 :         if (needLock)
     230         168 :             LockRelationForExtension(rel, ExclusiveLock);
     231         168 :         num_pages = RelationGetNumberOfBlocks(rel);
     232         168 :         if (needLock)
     233         168 :             UnlockRelationForExtension(rel, ExclusiveLock);
     234             : 
     235             :         /* Quit if we've scanned the whole relation */
     236         168 :         if (p.current_blocknum >= num_pages)
     237          84 :             break;
     238             : 
     239          84 :         p.last_exclusive = num_pages;
     240             : 
     241             :         /* Iterate over pages, then loop back to recheck relation length */
     242             :         while (true)
     243        2310 :         {
     244             :             Buffer      buf;
     245             : 
     246             :             /* call vacuum_delay_point while not holding any buffer lock */
     247        2394 :             vacuum_delay_point(false);
     248             : 
     249        2394 :             buf = read_stream_next_buffer(stream, NULL);
     250             : 
     251        2394 :             if (!BufferIsValid(buf))
     252          84 :                 break;
     253             : 
     254        2310 :             gistvacuumpage(&vstate, buf);
     255             :         }
     256             : 
     257             :         /*
     258             :          * We have to reset the read stream to use it again. After returning
     259             :          * InvalidBuffer, the read stream API won't invoke our callback again
     260             :          * until the stream has been reset.
     261             :          */
     262          84 :         read_stream_reset(stream);
     263             :     }
     264             : 
     265          84 :     read_stream_end(stream);
     266             : 
     267             :     /*
     268             :      * If we found any recyclable pages (and recorded them in the FSM), then
     269             :      * forcibly update the upper-level FSM pages to ensure that searchers can
     270             :      * find them.  It's possible that the pages were also found during
     271             :      * previous scans and so this is a waste of time, but it's cheap enough
     272             :      * relative to scanning the index that it shouldn't matter much, and
     273             :      * making sure that free pages are available sooner not later seems
     274             :      * worthwhile.
     275             :      *
     276             :      * Note that if no recyclable pages exist, we don't bother vacuuming the
     277             :      * FSM at all.
     278             :      */
     279          84 :     if (stats->pages_free > 0)
     280           0 :         IndexFreeSpaceMapVacuum(rel);
     281             : 
     282             :     /* update statistics */
     283          84 :     stats->num_pages = num_pages;
     284             : 
     285             :     /*
     286             :      * If we saw any empty pages, try to unlink them from the tree so that
     287             :      * they can be reused.
     288             :      */
     289          84 :     gistvacuum_delete_empty_pages(info, &vstate);
     290             : 
     291             :     /* we don't need the internal and empty page sets anymore */
     292          84 :     MemoryContextDelete(vstate.page_set_context);
     293          84 :     vstate.page_set_context = NULL;
     294          84 :     vstate.internal_page_set = NULL;
     295          84 :     vstate.empty_leaf_set = NULL;
     296          84 : }
     297             : 
     298             : /*
     299             :  * gistvacuumpage --- VACUUM one page
     300             :  *
     301             :  * This processes a single page for gistbulkdelete(). `buffer` contains the
     302             :  * page to process. In some cases we must go back and reexamine
     303             :  * previously-scanned pages; this routine recurses when necessary to handle
     304             :  * that case.
     305             :  */
     306             : static void
     307        2310 : gistvacuumpage(GistVacState *vstate, Buffer buffer)
     308             : {
     309        2310 :     IndexVacuumInfo *info = vstate->info;
     310        2310 :     IndexBulkDeleteCallback callback = vstate->callback;
     311        2310 :     void       *callback_state = vstate->callback_state;
     312        2310 :     Relation    rel = info->index;
     313        2310 :     BlockNumber orig_blkno = BufferGetBlockNumber(buffer);
     314             :     Page        page;
     315             :     BlockNumber recurse_to;
     316             : 
     317             :     /*
     318             :      * orig_blkno is the highest block number reached by the outer
     319             :      * gistvacuumscan() loop. This will be the same as blkno unless we are
     320             :      * recursing to reexamine a previous page.
     321             :      */
     322        2310 :     BlockNumber blkno = orig_blkno;
     323             : 
     324        2310 : restart:
     325        2310 :     recurse_to = InvalidBlockNumber;
     326             : 
     327             :     /*
     328             :      * We are not going to stay here for a long time, aggressively grab an
     329             :      * exclusive lock.
     330             :      */
     331        2310 :     LockBuffer(buffer, GIST_EXCLUSIVE);
     332        2310 :     page = (Page) BufferGetPage(buffer);
     333             : 
     334        2310 :     if (gistPageRecyclable(page))
     335             :     {
     336             :         /* Okay to recycle this page */
     337           0 :         RecordFreeIndexPage(rel, blkno);
     338           0 :         vstate->stats->pages_deleted++;
     339           0 :         vstate->stats->pages_free++;
     340             :     }
     341        2310 :     else if (GistPageIsDeleted(page))
     342             :     {
     343             :         /* Already deleted, but can't recycle yet */
     344           0 :         vstate->stats->pages_deleted++;
     345             :     }
     346        2310 :     else if (GistPageIsLeaf(page))
     347             :     {
     348             :         OffsetNumber todelete[MaxOffsetNumber];
     349        2258 :         int         ntodelete = 0;
     350             :         int         nremain;
     351        2258 :         GISTPageOpaque opaque = GistPageGetOpaque(page);
     352        2258 :         OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
     353             : 
     354             :         /*
     355             :          * Check whether we need to recurse back to earlier pages.  What we
     356             :          * are concerned about is a page split that happened since we started
     357             :          * the vacuum scan.  If the split moved some tuples to a lower page
     358             :          * then we might have missed 'em.  If so, set up for tail recursion.
     359             :          *
     360             :          * This is similar to the checks we do during searches, when following
     361             :          * a downlink, but we don't need to jump to higher-numbered pages,
     362             :          * because we will process them later, anyway.
     363             :          */
     364        4516 :         if ((GistFollowRight(page) ||
     365        2258 :              vstate->startNSN < GistPageGetNSN(page)) &&
     366           0 :             (opaque->rightlink != InvalidBlockNumber) &&
     367           0 :             (opaque->rightlink < orig_blkno))
     368             :         {
     369           0 :             recurse_to = opaque->rightlink;
     370             :         }
     371             : 
     372             :         /*
     373             :          * Scan over all items to see which ones need to be deleted according
     374             :          * to the callback function.
     375             :          */
     376        2258 :         if (callback)
     377             :         {
     378             :             OffsetNumber off;
     379             : 
     380       60368 :             for (off = FirstOffsetNumber;
     381             :                  off <= maxoff;
     382       59860 :                  off = OffsetNumberNext(off))
     383             :             {
     384       59860 :                 ItemId      iid = PageGetItemId(page, off);
     385       59860 :                 IndexTuple  idxtuple = (IndexTuple) PageGetItem(page, iid);
     386             : 
     387       59860 :                 if (callback(&(idxtuple->t_tid), callback_state))
     388       44820 :                     todelete[ntodelete++] = off;
     389             :             }
     390             :         }
     391             : 
     392             :         /*
     393             :          * Apply any needed deletes.  We issue just one WAL record per page,
     394             :          * so as to minimize WAL traffic.
     395             :          */
     396        2258 :         if (ntodelete > 0)
     397             :         {
     398         490 :             START_CRIT_SECTION();
     399             : 
     400         490 :             MarkBufferDirty(buffer);
     401             : 
     402         490 :             PageIndexMultiDelete(page, todelete, ntodelete);
     403         490 :             GistMarkTuplesDeleted(page);
     404             : 
     405         490 :             if (RelationNeedsWAL(rel))
     406         490 :             {
     407             :                 XLogRecPtr  recptr;
     408             : 
     409         490 :                 recptr = gistXLogUpdate(buffer,
     410             :                                         todelete, ntodelete,
     411             :                                         NULL, 0, InvalidBuffer);
     412         490 :                 PageSetLSN(page, recptr);
     413             :             }
     414             :             else
     415           0 :                 PageSetLSN(page, gistGetFakeLSN(rel));
     416             : 
     417         490 :             END_CRIT_SECTION();
     418             : 
     419         490 :             vstate->stats->tuples_removed += ntodelete;
     420             :             /* must recompute maxoff */
     421         490 :             maxoff = PageGetMaxOffsetNumber(page);
     422             :         }
     423             : 
     424        2258 :         nremain = maxoff - FirstOffsetNumber + 1;
     425        2258 :         if (nremain == 0)
     426             :         {
     427             :             /*
     428             :              * The page is now completely empty.  Remember its block number,
     429             :              * so that we will try to delete the page in the second stage.
     430             :              *
     431             :              * Skip this when recursing, because IntegerSet requires that the
     432             :              * values are added in ascending order.  The next VACUUM will pick
     433             :              * it up.
     434             :              */
     435         174 :             if (blkno == orig_blkno)
     436         174 :                 intset_add_member(vstate->empty_leaf_set, blkno);
     437             :         }
     438             :         else
     439        2084 :             vstate->stats->num_index_tuples += nremain;
     440             :     }
     441             :     else
     442             :     {
     443             :         /*
     444             :          * On an internal page, check for "invalid tuples", left behind by an
     445             :          * incomplete page split on PostgreSQL 9.0 or below.  These are not
     446             :          * created by newer PostgreSQL versions, but unfortunately, there is
     447             :          * no version number anywhere in a GiST index, so we don't know
     448             :          * whether this index might still contain invalid tuples or not.
     449             :          */
     450          52 :         OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
     451             :         OffsetNumber off;
     452             : 
     453        2278 :         for (off = FirstOffsetNumber;
     454             :              off <= maxoff;
     455        2226 :              off = OffsetNumberNext(off))
     456             :         {
     457        2226 :             ItemId      iid = PageGetItemId(page, off);
     458        2226 :             IndexTuple  idxtuple = (IndexTuple) PageGetItem(page, iid);
     459             : 
     460        2226 :             if (GistTupleIsInvalid(idxtuple))
     461           0 :                 ereport(LOG,
     462             :                         (errmsg("index \"%s\" contains an inner tuple marked as invalid",
     463             :                                 RelationGetRelationName(rel)),
     464             :                          errdetail("This is caused by an incomplete page split at crash recovery before upgrading to PostgreSQL 9.1."),
     465             :                          errhint("Please REINDEX it.")));
     466             :         }
     467             : 
     468             :         /*
     469             :          * Remember the block number of this page, so that we can revisit it
     470             :          * later in gistvacuum_delete_empty_pages(), when we search for
     471             :          * parents of empty leaf pages.
     472             :          */
     473          52 :         if (blkno == orig_blkno)
     474          52 :             intset_add_member(vstate->internal_page_set, blkno);
     475             :     }
     476             : 
     477        2310 :     UnlockReleaseBuffer(buffer);
     478             : 
     479             :     /*
     480             :      * This is really tail recursion, but if the compiler is too stupid to
     481             :      * optimize it as such, we'd eat an uncomfortably large amount of stack
     482             :      * space per recursion level (due to the deletable[] array).  A failure is
     483             :      * improbable since the number of levels isn't likely to be large ... but
     484             :      * just in case, let's hand-optimize into a loop.
     485             :      */
     486        2310 :     if (recurse_to != InvalidBlockNumber)
     487             :     {
     488           0 :         blkno = recurse_to;
     489             : 
     490             :         /* check for vacuum delay while not holding any buffer lock */
     491           0 :         vacuum_delay_point(false);
     492             : 
     493           0 :         buffer = ReadBufferExtended(rel, MAIN_FORKNUM, blkno, RBM_NORMAL,
     494             :                                     info->strategy);
     495           0 :         goto restart;
     496             :     }
     497        2310 : }
     498             : 
     499             : /*
     500             :  * Scan all internal pages, and try to delete their empty child pages.
     501             :  */
     502             : static void
     503          84 : gistvacuum_delete_empty_pages(IndexVacuumInfo *info, GistVacState *vstate)
     504             : {
     505          84 :     Relation    rel = info->index;
     506             :     BlockNumber empty_pages_remaining;
     507             :     uint64      blkno;
     508             : 
     509             :     /*
     510             :      * Rescan all inner pages to find those that have empty child pages.
     511             :      */
     512          84 :     empty_pages_remaining = intset_num_entries(vstate->empty_leaf_set);
     513          84 :     intset_begin_iterate(vstate->internal_page_set);
     514         100 :     while (empty_pages_remaining > 0 &&
     515          14 :            intset_iterate_next(vstate->internal_page_set, &blkno))
     516             :     {
     517             :         Buffer      buffer;
     518             :         Page        page;
     519             :         OffsetNumber off,
     520             :                     maxoff;
     521             :         OffsetNumber todelete[MaxOffsetNumber];
     522             :         BlockNumber leafs_to_delete[MaxOffsetNumber];
     523             :         int         ntodelete;
     524             :         int         deleted;
     525             : 
     526           2 :         buffer = ReadBufferExtended(rel, MAIN_FORKNUM, (BlockNumber) blkno,
     527             :                                     RBM_NORMAL, info->strategy);
     528             : 
     529           2 :         LockBuffer(buffer, GIST_SHARE);
     530           2 :         page = (Page) BufferGetPage(buffer);
     531             : 
     532           2 :         if (PageIsNew(page) || GistPageIsDeleted(page) || GistPageIsLeaf(page))
     533             :         {
     534             :             /*
     535             :              * This page was an internal page earlier, but now it's something
     536             :              * else. Shouldn't happen...
     537             :              */
     538             :             Assert(false);
     539           0 :             UnlockReleaseBuffer(buffer);
     540           0 :             continue;
     541             :         }
     542             : 
     543             :         /*
     544             :          * Scan all the downlinks, and see if any of them point to empty leaf
     545             :          * pages.
     546             :          */
     547           2 :         maxoff = PageGetMaxOffsetNumber(page);
     548           2 :         ntodelete = 0;
     549         328 :         for (off = FirstOffsetNumber;
     550         326 :              off <= maxoff && ntodelete < maxoff - 1;
     551         326 :              off = OffsetNumberNext(off))
     552             :         {
     553         326 :             ItemId      iid = PageGetItemId(page, off);
     554         326 :             IndexTuple  idxtuple = (IndexTuple) PageGetItem(page, iid);
     555             :             BlockNumber leafblk;
     556             : 
     557         326 :             leafblk = ItemPointerGetBlockNumber(&(idxtuple->t_tid));
     558         326 :             if (intset_is_member(vstate->empty_leaf_set, leafblk))
     559             :             {
     560         162 :                 leafs_to_delete[ntodelete] = leafblk;
     561         162 :                 todelete[ntodelete++] = off;
     562             :             }
     563             :         }
     564             : 
     565             :         /*
     566             :          * In order to avoid deadlock, child page must be locked before
     567             :          * parent, so we must release the lock on the parent, lock the child,
     568             :          * and then re-acquire the lock the parent.  (And we wouldn't want to
     569             :          * do I/O, while holding a lock, anyway.)
     570             :          *
     571             :          * At the instant that we're not holding a lock on the parent, the
     572             :          * downlink might get moved by a concurrent insert, so we must
     573             :          * re-check that it still points to the same child page after we have
     574             :          * acquired both locks.  Also, another backend might have inserted a
     575             :          * tuple to the page, so that it is no longer empty.  gistdeletepage()
     576             :          * re-checks all these conditions.
     577             :          */
     578           2 :         LockBuffer(buffer, GIST_UNLOCK);
     579             : 
     580           2 :         deleted = 0;
     581         164 :         for (int i = 0; i < ntodelete; i++)
     582             :         {
     583             :             Buffer      leafbuf;
     584             : 
     585             :             /*
     586             :              * Don't remove the last downlink from the parent.  That would
     587             :              * confuse the insertion code.
     588             :              */
     589         162 :             if (PageGetMaxOffsetNumber(page) == FirstOffsetNumber)
     590           0 :                 break;
     591             : 
     592         162 :             leafbuf = ReadBufferExtended(rel, MAIN_FORKNUM, leafs_to_delete[i],
     593             :                                          RBM_NORMAL, info->strategy);
     594         162 :             LockBuffer(leafbuf, GIST_EXCLUSIVE);
     595         162 :             gistcheckpage(rel, leafbuf);
     596             : 
     597         162 :             LockBuffer(buffer, GIST_EXCLUSIVE);
     598         162 :             if (gistdeletepage(info, vstate->stats,
     599         162 :                                buffer, todelete[i] - deleted,
     600             :                                leafbuf))
     601         162 :                 deleted++;
     602         162 :             LockBuffer(buffer, GIST_UNLOCK);
     603             : 
     604         162 :             UnlockReleaseBuffer(leafbuf);
     605             :         }
     606             : 
     607           2 :         ReleaseBuffer(buffer);
     608             : 
     609             :         /*
     610             :          * We can stop the scan as soon as we have seen the downlinks, even if
     611             :          * we were not able to remove them all.
     612             :          */
     613           2 :         empty_pages_remaining -= ntodelete;
     614             :     }
     615          84 : }
     616             : 
     617             : /*
     618             :  * gistdeletepage takes a leaf page, and its parent, and tries to delete the
     619             :  * leaf.  Both pages must be locked.
     620             :  *
     621             :  * Even if the page was empty when we first saw it, a concurrent inserter might
     622             :  * have added a tuple to it since.  Similarly, the downlink might have moved.
     623             :  * We re-check all the conditions, to make sure the page is still deletable,
     624             :  * before modifying anything.
     625             :  *
     626             :  * Returns true, if the page was deleted, and false if a concurrent update
     627             :  * prevented it.
     628             :  */
     629             : static bool
     630         162 : gistdeletepage(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
     631             :                Buffer parentBuffer, OffsetNumber downlink,
     632             :                Buffer leafBuffer)
     633             : {
     634         162 :     Page        parentPage = BufferGetPage(parentBuffer);
     635         162 :     Page        leafPage = BufferGetPage(leafBuffer);
     636             :     ItemId      iid;
     637             :     IndexTuple  idxtuple;
     638             :     XLogRecPtr  recptr;
     639             :     FullTransactionId txid;
     640             : 
     641             :     /*
     642             :      * Check that the leaf is still empty and deletable.
     643             :      */
     644         162 :     if (!GistPageIsLeaf(leafPage))
     645             :     {
     646             :         /* a leaf page should never become a non-leaf page */
     647             :         Assert(false);
     648           0 :         return false;
     649             :     }
     650             : 
     651         162 :     if (GistFollowRight(leafPage))
     652           0 :         return false;           /* don't mess with a concurrent page split */
     653             : 
     654         162 :     if (PageGetMaxOffsetNumber(leafPage) != InvalidOffsetNumber)
     655           0 :         return false;           /* not empty anymore */
     656             : 
     657             :     /*
     658             :      * Ok, the leaf is deletable.  Is the downlink in the parent page still
     659             :      * valid?  It might have been moved by a concurrent insert.  We could try
     660             :      * to re-find it by scanning the page again, possibly moving right if the
     661             :      * was split.  But for now, let's keep it simple and just give up.  The
     662             :      * next VACUUM will pick it up.
     663             :      */
     664         162 :     if (PageIsNew(parentPage) || GistPageIsDeleted(parentPage) ||
     665         162 :         GistPageIsLeaf(parentPage))
     666             :     {
     667             :         /* shouldn't happen, internal pages are never deleted */
     668             :         Assert(false);
     669           0 :         return false;
     670             :     }
     671             : 
     672         162 :     if (PageGetMaxOffsetNumber(parentPage) < downlink
     673         162 :         || PageGetMaxOffsetNumber(parentPage) <= FirstOffsetNumber)
     674           0 :         return false;
     675             : 
     676         162 :     iid = PageGetItemId(parentPage, downlink);
     677         162 :     idxtuple = (IndexTuple) PageGetItem(parentPage, iid);
     678         324 :     if (BufferGetBlockNumber(leafBuffer) !=
     679         162 :         ItemPointerGetBlockNumber(&(idxtuple->t_tid)))
     680           0 :         return false;
     681             : 
     682             :     /*
     683             :      * All good, proceed with the deletion.
     684             :      *
     685             :      * The page cannot be immediately recycled, because in-progress scans that
     686             :      * saw the downlink might still visit it.  Mark the page with the current
     687             :      * next-XID counter, so that we know when it can be recycled.  Once that
     688             :      * XID becomes older than GlobalXmin, we know that all scans that are
     689             :      * currently in progress must have ended.  (That's much more conservative
     690             :      * than needed, but let's keep it safe and simple.)
     691             :      */
     692         162 :     txid = ReadNextFullTransactionId();
     693             : 
     694         162 :     START_CRIT_SECTION();
     695             : 
     696             :     /* mark the page as deleted */
     697         162 :     MarkBufferDirty(leafBuffer);
     698         162 :     GistPageSetDeleted(leafPage, txid);
     699         162 :     stats->pages_newly_deleted++;
     700         162 :     stats->pages_deleted++;
     701             : 
     702             :     /* remove the downlink from the parent */
     703         162 :     MarkBufferDirty(parentBuffer);
     704         162 :     PageIndexTupleDelete(parentPage, downlink);
     705             : 
     706         162 :     if (RelationNeedsWAL(info->index))
     707         162 :         recptr = gistXLogPageDelete(leafBuffer, txid, parentBuffer, downlink);
     708             :     else
     709           0 :         recptr = gistGetFakeLSN(info->index);
     710         162 :     PageSetLSN(parentPage, recptr);
     711         162 :     PageSetLSN(leafPage, recptr);
     712             : 
     713         162 :     END_CRIT_SECTION();
     714             : 
     715         162 :     return true;
     716             : }

Generated by: LCOV version 1.14