ginvacuum.c File Reference

#include "postgres.h"
#include "access/gin_private.h"
#include "access/ginxlog.h"
#include "access/xloginsert.h"
#include "commands/vacuum.h"
#include "miscadmin.h"
#include "storage/indexfsm.h"
#include "storage/lmgr.h"
#include "storage/predicate.h"
#include "storage/read_stream.h"
#include "utils/memutils.h"

Include dependency graph for ginvacuum.c:

Go to the source code of this file.

Data Structures
struct	GinVacuumState
struct	DataPageDeleteStack

Typedefs
typedef struct DataPageDeleteStack	DataPageDeleteStack

Functions
ItemPointer	ginVacuumItemPointers (GinVacuumState *gvs, ItemPointerData *items, int nitem, int *nremaining)
static void	xlogVacuumPage (Relation index, Buffer buffer)
static void	ginDeletePostingPage (GinVacuumState *gvs, Buffer dBuffer, Buffer lBuffer, Buffer pBuffer, OffsetNumber myoff, bool isParentRoot)
static bool	ginScanPostingTreeToDelete (GinVacuumState *gvs, DataPageDeleteStack *myStackItem)
static bool	ginVacuumPostingTreeLeaves (GinVacuumState *gvs, BlockNumber blkno)
static void	ginVacuumPostingTree (GinVacuumState *gvs, BlockNumber rootBlkno)
static Page	ginVacuumEntryPage (GinVacuumState *gvs, Buffer buffer, BlockNumber *roots, uint32 *nroot)
IndexBulkDeleteResult *	ginbulkdelete (IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
IndexBulkDeleteResult *	ginvacuumcleanup (IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
bool	GinPageIsRecyclable (Page page)

Typedef Documentation

DataPageDeleteStack

typedef struct DataPageDeleteStack DataPageDeleteStack

Function Documentation

ginbulkdelete()

IndexBulkDeleteResult * ginbulkdelete	(	IndexVacuumInfo *	info,
		IndexBulkDeleteResult *	stats,
		IndexBulkDeleteCallback	callback,
		void *	callback_state
	)

Definition at line 602 of file ginvacuum.c.

{
    Relation    index = info->index;
    BlockNumber blkno = GIN_ROOT_BLKNO;
    GinVacuumState gvs;
    Buffer      buffer;
    BlockNumber rootOfPostingTree[BLCKSZ / (sizeof(IndexTupleData) + sizeof(ItemId))];
    uint32      nRoot;
 
    gvs.tmpCxt = AllocSetContextCreate(CurrentMemoryContext,
                                       "Gin vacuum temporary context",
                                       ALLOCSET_DEFAULT_SIZES);
    gvs.index = index;
    gvs.callback = callback;
    gvs.callback_state = callback_state;
    gvs.strategy = info->strategy;
    initGinState(&gvs.ginstate, index);
 
    /* first time through? */
    if (stats == NULL)
    {
        /* Yes, so initialize stats to zeroes */
        stats = palloc0_object(IndexBulkDeleteResult);
 
        /*
         * and cleanup any pending inserts
         */
        ginInsertCleanup(&gvs.ginstate, !AmAutoVacuumWorkerProcess(),
                         false, true, stats);
    }
 
    /* we'll re-count the tuples each time */
    stats->num_index_tuples = 0;
    gvs.result = stats;
 
    buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
                                RBM_NORMAL, info->strategy);
 
    /* find leaf page */
    for (;;)
    {
        Page        page = BufferGetPage(buffer);
        IndexTuple  itup;
 
        LockBuffer(buffer, GIN_SHARE);
 
        Assert(!GinPageIsData(page));
 
        if (GinPageIsLeaf(page))
        {
            LockBuffer(buffer, GIN_UNLOCK);
            LockBuffer(buffer, GIN_EXCLUSIVE);
 
            if (blkno == GIN_ROOT_BLKNO && !GinPageIsLeaf(page))
            {
                LockBuffer(buffer, GIN_UNLOCK);
                continue;       /* check it one more */
            }
            break;
        }
 
        Assert(PageGetMaxOffsetNumber(page) >= FirstOffsetNumber);
 
        itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, FirstOffsetNumber));
        blkno = GinGetDownlink(itup);
        Assert(blkno != InvalidBlockNumber);
 
        UnlockReleaseBuffer(buffer);
        buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
                                    RBM_NORMAL, info->strategy);
    }
 
    /* right now we found leftmost page in entry's BTree */
 
    for (;;)
    {
        Page        page = BufferGetPage(buffer);
        Page        resPage;
        uint32      i;
 
        Assert(!GinPageIsData(page));
 
        resPage = ginVacuumEntryPage(&gvs, buffer, rootOfPostingTree, &nRoot);
 
        blkno = GinPageGetOpaque(page)->rightlink;
 
        if (resPage)
        {
            START_CRIT_SECTION();
            PageRestoreTempPage(resPage, page);
            MarkBufferDirty(buffer);
            xlogVacuumPage(gvs.index, buffer);
            END_CRIT_SECTION();
            UnlockReleaseBuffer(buffer);
        }
        else
        {
            UnlockReleaseBuffer(buffer);
        }
 
        vacuum_delay_point(false);
 
        for (i = 0; i < nRoot; i++)
        {
            ginVacuumPostingTree(&gvs, rootOfPostingTree[i]);
            vacuum_delay_point(false);
        }
 
        if (blkno == InvalidBlockNumber)    /* rightmost page */
            break;
 
        buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
                                    RBM_NORMAL, info->strategy);
        LockBuffer(buffer, GIN_EXCLUSIVE);
    }
 
    MemoryContextDelete(gvs.tmpCxt);
 
    return gvs.result;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AmAutoVacuumWorkerProcess, Assert, DataPageDeleteStack::buffer, BufferGetPage(), callback(), CurrentMemoryContext, END_CRIT_SECTION, fb(), FirstOffsetNumber, GIN_EXCLUSIVE, GIN_ROOT_BLKNO, GIN_SHARE, GIN_UNLOCK, GinGetDownlink, ginInsertCleanup(), GinPageGetOpaque, GinPageIsData, GinPageIsLeaf, ginVacuumEntryPage(), ginVacuumPostingTree(), i, IndexVacuumInfo::index, initGinState(), InvalidBlockNumber, LockBuffer(), MAIN_FORKNUM, MarkBufferDirty(), MemoryContextDelete(), IndexBulkDeleteResult::num_index_tuples, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageRestoreTempPage(), palloc0_object, RBM_NORMAL, ReadBufferExtended(), START_CRIT_SECTION, IndexVacuumInfo::strategy, GinVacuumState::tmpCxt, UnlockReleaseBuffer(), vacuum_delay_point(), and xlogVacuumPage().

Referenced by ginhandler().

ginDeletePostingPage()

static void ginDeletePostingPage ( GinVacuumState *  gvs, Buffer  dBuffer, Buffer  lBuffer, Buffer  pBuffer, OffsetNumber  myoff, bool  isParentRoot  )

static

Definition at line 152 of file ginvacuum.c.

{
    Page        page,
                parentPage;
    BlockNumber rightlink;
    BlockNumber deleteBlkno = BufferGetBlockNumber(dBuffer);
 
    /*
     * This function MUST be called only if someone of parent pages hold
     * exclusive cleanup lock. This guarantees that no insertions currently
     * happen in this subtree. Caller also acquires Exclusive locks on
     * deletable, parent and left pages.
     */
 
    page = BufferGetPage(dBuffer);
    rightlink = GinPageGetOpaque(page)->rightlink;
 
    /*
     * Any insert which would have gone on the leaf block will now go to its
     * right sibling.
     */
    PredicateLockPageCombine(gvs->index, deleteBlkno, rightlink);
 
    START_CRIT_SECTION();
 
    /* Unlink the page by changing left sibling's rightlink */
    page = BufferGetPage(lBuffer);
    GinPageGetOpaque(page)->rightlink = rightlink;
 
    /* Delete downlink from parent */
    parentPage = BufferGetPage(pBuffer);
#ifdef USE_ASSERT_CHECKING
    do
    {
        PostingItem *tod = GinDataPageGetPostingItem(parentPage, myoff);
 
        Assert(PostingItemGetBlockNumber(tod) == deleteBlkno);
    } while (0);
#endif
    GinPageDeletePostingItem(parentPage, myoff);
 
    page = BufferGetPage(dBuffer);
 
    /*
     * we shouldn't change rightlink field to save workability of running
     * search scan
     */
 
    /*
     * Mark page as deleted, and remember last xid which could know its
     * address.
     */
    GinPageSetDeleted(page);
    GinPageSetDeleteXid(page, ReadNextTransactionId());
 
    MarkBufferDirty(pBuffer);
    MarkBufferDirty(lBuffer);
    MarkBufferDirty(dBuffer);
 
    if (RelationNeedsWAL(gvs->index))
    {
        XLogRecPtr  recptr;
        ginxlogDeletePage data;
 
        /*
         * We can't pass REGBUF_STANDARD for the deleted page, because we
         * didn't set pd_lower on pre-9.4 versions. The page might've been
         * binary-upgraded from an older version, and hence not have pd_lower
         * set correctly. Ditto for the left page, but removing the item from
         * the parent updated its pd_lower, so we know that's OK at this
         * point.
         */
        XLogBeginInsert();
        XLogRegisterBuffer(0, dBuffer, 0);
        XLogRegisterBuffer(1, pBuffer, REGBUF_STANDARD);
        XLogRegisterBuffer(2, lBuffer, 0);
 
        data.parentOffset = myoff;
        data.rightLink = GinPageGetOpaque(page)->rightlink;
        data.deleteXid = GinPageGetDeleteXid(page);
 
        XLogRegisterData(&data, sizeof(ginxlogDeletePage));
 
        recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_DELETE_PAGE);
        PageSetLSN(page, recptr);
        PageSetLSN(parentPage, recptr);
        PageSetLSN(BufferGetPage(lBuffer), recptr);
    }
 
    END_CRIT_SECTION();
 
    gvs->result->pages_newly_deleted++;
    gvs->result->pages_deleted++;
}

References Assert, BufferGetBlockNumber(), BufferGetPage(), data, END_CRIT_SECTION, fb(), GinDataPageGetPostingItem, GinPageDeletePostingItem(), GinPageGetDeleteXid, GinPageGetOpaque, GinPageSetDeleted, GinPageSetDeleteXid, MarkBufferDirty(), DataPageDeleteStack::myoff, PageSetLSN(), PostingItemGetBlockNumber, PredicateLockPageCombine(), ReadNextTransactionId(), REGBUF_STANDARD, RelationNeedsWAL, START_CRIT_SECTION, XLOG_GIN_DELETE_PAGE, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by ginScanPostingTreeToDelete().

GinPageIsRecyclable()

bool GinPageIsRecyclable

(

Page

page

)

Definition at line 862 of file ginvacuum.c.

{
    TransactionId delete_xid;
 
    if (PageIsNew(page))
        return true;
 
    if (!GinPageIsDeleted(page))
        return false;
 
    delete_xid = GinPageGetDeleteXid(page);
 
    if (!TransactionIdIsValid(delete_xid))
        return true;
 
    /*
     * If no backend still could view delete_xid as in running, all scans
     * concurrent with ginDeletePostingPage() must have finished.
     */
    return GlobalVisCheckRemovableXid(NULL, delete_xid);
}

References fb(), GinPageGetDeleteXid, GinPageIsDeleted, GlobalVisCheckRemovableXid(), PageIsNew(), and TransactionIdIsValid.

Referenced by GinNewBuffer(), and ginvacuumcleanup().

ginScanPostingTreeToDelete()

static bool ginScanPostingTreeToDelete ( GinVacuumState *  gvs, DataPageDeleteStack *  myStackItem  )

static

Definition at line 269 of file ginvacuum.c.

{
    Buffer      buffer = myStackItem->buffer;
    Page        page;
    bool        pageWasDeleted = false;
    bool        isempty;
 
    page = BufferGetPage(buffer);
 
    Assert(GinPageIsData(page));
 
    if (!GinPageIsLeaf(page))
    {
        OffsetNumber i;
 
        for (i = FirstOffsetNumber; i <= GinPageGetOpaque(page)->maxoff;)
        {
            PostingItem *pitem = GinDataPageGetPostingItem(page, i);
            Buffer      childBuffer;
 
            childBuffer = ReadBufferExtended(gvs->index,
                                             MAIN_FORKNUM,
                                             PostingItemGetBlockNumber(pitem),
                                             RBM_NORMAL, gvs->strategy);
            LockBuffer(childBuffer, GIN_EXCLUSIVE);
 
            /* Allocate a child stack entry on first use; reuse thereafter */
            if (!myStackItem->child)
            {
                myStackItem->child = palloc0_object(DataPageDeleteStack);
                myStackItem->child->parent = myStackItem;
                myStackItem->child->leftBuffer = InvalidBuffer;
            }
 
            myStackItem->child->buffer = childBuffer;
            myStackItem->child->isRoot = false;
            myStackItem->child->myoff = i;
 
            /*
             * Recurse into child.  If the child page was deleted, its
             * downlink was removed from our page, so re-examine the same
             * offset; otherwise advance to the next downlink.
             */
            if (!ginScanPostingTreeToDelete(gvs, myStackItem->child))
                i++;
        }
        myStackItem->buffer = InvalidBuffer;
 
        /*
         * After processing all children at this level, release the child
         * level's leftBuffer if we're at the rightmost page.  There is no
         * right sibling that could need it for deletion.
         */
        if (GinPageRightMost(page) && BufferIsValid(myStackItem->child->leftBuffer))
        {
            UnlockReleaseBuffer(myStackItem->child->leftBuffer);
            myStackItem->child->leftBuffer = InvalidBuffer;
        }
    }
 
    if (GinPageIsLeaf(page))
        isempty = GinDataLeafPageIsEmpty(page);
    else
        isempty = GinPageGetOpaque(page)->maxoff < FirstOffsetNumber;
 
    if (isempty)
    {
        /*
         * Proceed to the ginDeletePostingPage() if that's not the leftmost or
         * the rightmost page.
         */
        if (BufferIsValid(myStackItem->leftBuffer) && !GinPageRightMost(page))
        {
            Assert(!myStackItem->isRoot);
            ginDeletePostingPage(gvs, buffer, myStackItem->leftBuffer,
                                 myStackItem->parent->buffer,
                                 myStackItem->myoff,
                                 myStackItem->parent->isRoot);
            pageWasDeleted = true;
        }
    }
 
    if (!pageWasDeleted)
    {
        /*
         * Keep this page as the new leftBuffer for this level: the next
         * sibling to the right might need it for deletion.  Release any
         * previously held left page first.
         */
        if (BufferIsValid(myStackItem->leftBuffer))
            UnlockReleaseBuffer(myStackItem->leftBuffer);
        myStackItem->leftBuffer = buffer;
    }
    else
    {
        /*
         * Page was deleted; release the buffer.  leftBuffer remains the same.
         */
        UnlockReleaseBuffer(buffer);
    }
 
    return pageWasDeleted;
}

References Assert, DataPageDeleteStack::buffer, BufferGetPage(), BufferIsValid(), fb(), FirstOffsetNumber, GIN_EXCLUSIVE, GinDataLeafPageIsEmpty, GinDataPageGetPostingItem, ginDeletePostingPage(), GinPageGetOpaque, GinPageIsData, GinPageIsLeaf, GinPageRightMost, ginScanPostingTreeToDelete(), i, InvalidBuffer, LockBuffer(), MAIN_FORKNUM, palloc0_object, PostingItemGetBlockNumber, RBM_NORMAL, ReadBufferExtended(), and UnlockReleaseBuffer().

Referenced by ginScanPostingTreeToDelete(), and ginVacuumPostingTree().

ginvacuumcleanup()

IndexBulkDeleteResult * ginvacuumcleanup	(	IndexVacuumInfo *	info,
		IndexBulkDeleteResult *	stats
	)

Definition at line 725 of file ginvacuum.c.

{
    Relation    index = info->index;
    bool        needLock;
    BlockNumber npages,
                blkno;
    BlockNumber totFreePages;
    GinState    ginstate;
    GinStatsData idxStat;
    BlockRangeReadStreamPrivate p;
    ReadStream *stream;
 
    /*
     * In an autovacuum analyze, we want to clean up pending insertions.
     * Otherwise, an ANALYZE-only call is a no-op.
     */
    if (info->analyze_only)
    {
        if (AmAutoVacuumWorkerProcess())
        {
            initGinState(&ginstate, index);
            ginInsertCleanup(&ginstate, false, true, true, stats);
        }
        return stats;
    }
 
    /*
     * Set up all-zero stats and cleanup pending inserts if ginbulkdelete
     * wasn't called
     */
    if (stats == NULL)
    {
        stats = palloc0_object(IndexBulkDeleteResult);
        initGinState(&ginstate, index);
        ginInsertCleanup(&ginstate, !AmAutoVacuumWorkerProcess(),
                         false, true, stats);
    }
 
    memset(&idxStat, 0, sizeof(idxStat));
 
    /*
     * XXX we always report the heap tuple count as the number of index
     * entries.  This is bogus if the index is partial, but it's real hard to
     * tell how many distinct heap entries are referenced by a GIN index.
     */
    stats->num_index_tuples = Max(info->num_heap_tuples, 0);
    stats->estimated_count = info->estimated_count;
 
    /*
     * Need lock unless it's local to this backend.
     */
    needLock = !RELATION_IS_LOCAL(index);
 
    if (needLock)
        LockRelationForExtension(index, ExclusiveLock);
    npages = RelationGetNumberOfBlocks(index);
    if (needLock)
        UnlockRelationForExtension(index, ExclusiveLock);
 
    totFreePages = 0;
 
    /* Scan all blocks starting from the root using streaming reads */
    p.current_blocknum = GIN_ROOT_BLKNO;
    p.last_exclusive = npages;
 
    /*
     * It is safe to use batchmode as block_range_read_stream_cb takes no
     * locks.
     */
    stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
                                        READ_STREAM_FULL |
                                        READ_STREAM_USE_BATCHING,
                                        info->strategy,
                                        index,
                                        MAIN_FORKNUM,
                                        block_range_read_stream_cb,
                                        &p,
                                        0);
 
    for (blkno = GIN_ROOT_BLKNO; blkno < npages; blkno++)
    {
        Buffer      buffer;
        Page        page;
 
        vacuum_delay_point(false);
 
        buffer = read_stream_next_buffer(stream, NULL);
 
        LockBuffer(buffer, GIN_SHARE);
        page = BufferGetPage(buffer);
 
        if (GinPageIsRecyclable(page))
        {
            Assert(blkno != GIN_ROOT_BLKNO);
            RecordFreeIndexPage(index, blkno);
            totFreePages++;
        }
        else if (GinPageIsData(page))
        {
            idxStat.nDataPages++;
        }
        else if (!GinPageIsList(page))
        {
            idxStat.nEntryPages++;
 
            if (GinPageIsLeaf(page))
                idxStat.nEntries += PageGetMaxOffsetNumber(page);
        }
 
        UnlockReleaseBuffer(buffer);
    }
 
    Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
    read_stream_end(stream);
 
    /* Update the metapage with accurate page and entry counts */
    idxStat.nTotalPages = npages;
    ginUpdateStats(info->index, &idxStat, false);
 
    /* Finally, vacuum the FSM */
    IndexFreeSpaceMapVacuum(info->index);
 
    stats->pages_free = totFreePages;
 
    if (needLock)
        LockRelationForExtension(index, ExclusiveLock);
    stats->num_pages = RelationGetNumberOfBlocks(index);
    if (needLock)
        UnlockRelationForExtension(index, ExclusiveLock);
 
    return stats;
}

References AmAutoVacuumWorkerProcess, IndexVacuumInfo::analyze_only, Assert, block_range_read_stream_cb(), DataPageDeleteStack::buffer, BufferGetPage(), BlockRangeReadStreamPrivate::current_blocknum, IndexVacuumInfo::estimated_count, IndexBulkDeleteResult::estimated_count, ExclusiveLock, fb(), GIN_ROOT_BLKNO, GIN_SHARE, ginInsertCleanup(), GinPageIsData, GinPageIsLeaf, GinPageIsList, GinPageIsRecyclable(), ginUpdateStats(), IndexVacuumInfo::index, IndexFreeSpaceMapVacuum(), initGinState(), InvalidBuffer, BlockRangeReadStreamPrivate::last_exclusive, LockBuffer(), LockRelationForExtension(), MAIN_FORKNUM, Max, IndexVacuumInfo::num_heap_tuples, IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, PageGetMaxOffsetNumber(), IndexBulkDeleteResult::pages_free, palloc0_object, read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, READ_STREAM_MAINTENANCE, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, RecordFreeIndexPage(), RELATION_IS_LOCAL, RelationGetNumberOfBlocks, IndexVacuumInfo::strategy, UnlockRelationForExtension(), UnlockReleaseBuffer(), and vacuum_delay_point().

Referenced by ginhandler().

ginVacuumEntryPage()

static Page ginVacuumEntryPage ( GinVacuumState *  gvs, Buffer  buffer, BlockNumber *  roots, uint32 *  nroot  )

static

Definition at line 493 of file ginvacuum.c.

{
    Page        origpage = BufferGetPage(buffer),
                tmppage;
    OffsetNumber i,
                maxoff = PageGetMaxOffsetNumber(origpage);
 
    tmppage = origpage;
 
    *nroot = 0;
 
    for (i = FirstOffsetNumber; i <= maxoff; i++)
    {
        IndexTuple  itup = (IndexTuple) PageGetItem(tmppage, PageGetItemId(tmppage, i));
 
        if (GinIsPostingTree(itup))
        {
            /*
             * store posting tree's roots for further processing, we can't
             * vacuum it just now due to risk of deadlocks with scans/inserts
             */
            roots[*nroot] = GinGetDownlink(itup);
            (*nroot)++;
        }
        else if (GinGetNPosting(itup) > 0)
        {
            int         nitems;
            ItemPointer items_orig;
            bool        free_items_orig;
            ItemPointer items;
 
            /* Get list of item pointers from the tuple. */
            if (GinItupIsCompressed(itup))
            {
                items_orig = ginPostingListDecode((GinPostingList *) GinGetPosting(itup), &nitems);
                free_items_orig = true;
            }
            else
            {
                items_orig = (ItemPointer) GinGetPosting(itup);
                nitems = GinGetNPosting(itup);
                free_items_orig = false;
            }
 
            /* Remove any items from the list that need to be vacuumed. */
            items = ginVacuumItemPointers(gvs, items_orig, nitems, &nitems);
 
            if (free_items_orig)
                pfree(items_orig);
 
            /* If any item pointers were removed, recreate the tuple. */
            if (items)
            {
                OffsetNumber attnum;
                Datum       key;
                GinNullCategory category;
                GinPostingList *plist;
                int         plistsize;
 
                if (nitems > 0)
                {
                    plist = ginCompressPostingList(items, nitems, GinMaxItemSize, NULL);
                    plistsize = SizeOfGinPostingList(plist);
                }
                else
                {
                    plist = NULL;
                    plistsize = 0;
                }
 
                /*
                 * if we already created a temporary page, make changes in
                 * place
                 */
                if (tmppage == origpage)
                {
                    /*
                     * On first difference, create a temporary copy of the
                     * page and copy the tuple's posting list to it.
                     */
                    tmppage = PageGetTempPageCopy(origpage);
 
                    /* set itup pointer to new page */
                    itup = (IndexTuple) PageGetItem(tmppage, PageGetItemId(tmppage, i));
                }
 
                attnum = gintuple_get_attrnum(&gvs->ginstate, itup);
                key = gintuple_get_key(&gvs->ginstate, itup, &category);
                itup = GinFormTuple(&gvs->ginstate, attnum, key, category,
                                    (char *) plist, plistsize,
                                    nitems, true);
                if (plist)
                    pfree(plist);
                PageIndexTupleDelete(tmppage, i);
 
                if (PageAddItem(tmppage, itup, IndexTupleSize(itup), i, false, false) != i)
                    elog(ERROR, "failed to add item to index page in \"%s\"",
                         RelationGetRelationName(gvs->index));
 
                pfree(itup);
                pfree(items);
            }
        }
    }
 
    return (tmppage == origpage) ? NULL : tmppage;
}

References attnum, DataPageDeleteStack::buffer, BufferGetPage(), elog, ERROR, fb(), FirstOffsetNumber, ginCompressPostingList(), GinFormTuple(), GinGetDownlink, GinGetNPosting, GinGetPosting, GinIsPostingTree, GinItupIsCompressed, GinMaxItemSize, ginPostingListDecode(), gintuple_get_attrnum(), gintuple_get_key(), ginVacuumItemPointers(), i, IndexTupleSize(), items, nitems, PageAddItem, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageGetTempPageCopy(), PageIndexTupleDelete(), pfree(), RelationGetRelationName, and SizeOfGinPostingList.

Referenced by ginbulkdelete().

ginVacuumItemPointers()

ItemPointer ginVacuumItemPointers	(	GinVacuumState *	gvs,
		ItemPointerData *	items,
		int	nitem,
		int *	nremaining
	)

Definition at line 48 of file ginvacuum.c.

{
    int         i,
                remaining = 0;
    ItemPointer tmpitems = NULL;
 
    /*
     * Iterate over TIDs array
     */
    for (i = 0; i < nitem; i++)
    {
        if (gvs->callback(items + i, gvs->callback_state))
        {
            gvs->result->tuples_removed += 1;
            if (!tmpitems)
            {
                /*
                 * First TID to be deleted: allocate memory to hold the
                 * remaining items.
                 */
                tmpitems = palloc_array(ItemPointerData, nitem);
                memcpy(tmpitems, items, sizeof(ItemPointerData) * i);
            }
        }
        else
        {
            gvs->result->num_index_tuples += 1;
            if (tmpitems)
                tmpitems[remaining] = items[i];
            remaining++;
        }
    }
 
    *nremaining = remaining;
    return tmpitems;
}

References fb(), i, items, palloc_array, and remaining.

Referenced by ginVacuumEntryPage(), and ginVacuumPostingTreeLeaf().

ginVacuumPostingTree()

static void ginVacuumPostingTree ( GinVacuumState *  gvs, BlockNumber  rootBlkno  )

static

Definition at line 442 of file ginvacuum.c.

{
    if (ginVacuumPostingTreeLeaves(gvs, rootBlkno))
    {
        /*
         * There is at least one empty page.  So we have to rescan the tree
         * deleting empty pages.
         */
        Buffer      buffer;
        DataPageDeleteStack root,
                   *ptr,
                   *tmp;
        bool        deleted PG_USED_FOR_ASSERTS_ONLY;
 
        buffer = ReadBufferExtended(gvs->index, MAIN_FORKNUM, rootBlkno,
                                    RBM_NORMAL, gvs->strategy);
 
        /*
         * Lock posting tree root for cleanup to ensure there are no
         * concurrent inserts.
         */
        LockBufferForCleanup(buffer);
 
        memset(&root, 0, sizeof(DataPageDeleteStack));
        root.buffer = buffer;
        root.leftBuffer = InvalidBuffer;
        root.myoff = InvalidOffsetNumber;
        root.isRoot = true;
 
        deleted = ginScanPostingTreeToDelete(gvs, &root);
        Assert(!deleted);
 
        ptr = root.child;
 
        while (ptr)
        {
            tmp = ptr->child;
            pfree(ptr);
            ptr = tmp;
        }
 
        UnlockReleaseBuffer(buffer);
    }
}

References Assert, DataPageDeleteStack::buffer, DataPageDeleteStack::child, fb(), ginScanPostingTreeToDelete(), ginVacuumPostingTreeLeaves(), InvalidBuffer, InvalidOffsetNumber, LockBufferForCleanup(), MAIN_FORKNUM, pfree(), PG_USED_FOR_ASSERTS_ONLY, RBM_NORMAL, ReadBufferExtended(), root, and UnlockReleaseBuffer().

Referenced by ginbulkdelete().

ginVacuumPostingTreeLeaves()

static bool ginVacuumPostingTreeLeaves ( GinVacuumState *  gvs, BlockNumber  blkno  )

static

Definition at line 379 of file ginvacuum.c.

{
    Buffer      buffer;
    Page        page;
    bool        hasVoidPage = false;
    MemoryContext oldCxt;
 
    /* Find leftmost leaf page of posting tree and lock it in exclusive mode */
    while (true)
    {
        PostingItem *pitem;
 
        buffer = ReadBufferExtended(gvs->index, MAIN_FORKNUM, blkno,
                                    RBM_NORMAL, gvs->strategy);
        LockBuffer(buffer, GIN_SHARE);
        page = BufferGetPage(buffer);
 
        Assert(GinPageIsData(page));
 
        if (GinPageIsLeaf(page))
        {
            LockBuffer(buffer, GIN_UNLOCK);
            LockBuffer(buffer, GIN_EXCLUSIVE);
            break;
        }
 
        Assert(PageGetMaxOffsetNumber(page) >= FirstOffsetNumber);
 
        pitem = GinDataPageGetPostingItem(page, FirstOffsetNumber);
        blkno = PostingItemGetBlockNumber(pitem);
        Assert(blkno != InvalidBlockNumber);
 
        UnlockReleaseBuffer(buffer);
    }
 
    /* Iterate all posting tree leaves using rightlinks and vacuum them */
    while (true)
    {
        oldCxt = MemoryContextSwitchTo(gvs->tmpCxt);
        ginVacuumPostingTreeLeaf(gvs->index, buffer, gvs);
        MemoryContextSwitchTo(oldCxt);
        MemoryContextReset(gvs->tmpCxt);
 
        if (GinDataLeafPageIsEmpty(page))
            hasVoidPage = true;
 
        blkno = GinPageGetOpaque(page)->rightlink;
 
        UnlockReleaseBuffer(buffer);
 
        if (blkno == InvalidBlockNumber)
            break;
 
        buffer = ReadBufferExtended(gvs->index, MAIN_FORKNUM, blkno,
                                    RBM_NORMAL, gvs->strategy);
        LockBuffer(buffer, GIN_EXCLUSIVE);
        page = BufferGetPage(buffer);
    }
 
    return hasVoidPage;
}

References Assert, DataPageDeleteStack::buffer, BufferGetPage(), fb(), FirstOffsetNumber, GIN_EXCLUSIVE, GIN_SHARE, GIN_UNLOCK, GinDataLeafPageIsEmpty, GinDataPageGetPostingItem, GinPageGetOpaque, GinPageIsData, GinPageIsLeaf, ginVacuumPostingTreeLeaf(), InvalidBlockNumber, LockBuffer(), MAIN_FORKNUM, MemoryContextReset(), MemoryContextSwitchTo(), PageGetMaxOffsetNumber(), PostingItemGetBlockNumber, RBM_NORMAL, ReadBufferExtended(), and UnlockReleaseBuffer().

Referenced by ginVacuumPostingTree().

xlogVacuumPage()

static void xlogVacuumPage ( Relation  index, Buffer  buffer  )

static

Definition at line 90 of file ginvacuum.c.

{
    Page        page = BufferGetPage(buffer);
    XLogRecPtr  recptr;
 
    /* This is only used for entry tree leaf pages. */
    Assert(!GinPageIsData(page));
    Assert(GinPageIsLeaf(page));
 
    if (!RelationNeedsWAL(index))
        return;
 
    /*
     * Always create a full image, we don't track the changes on the page at
     * any more fine-grained level. This could obviously be improved...
     */
    XLogBeginInsert();
    XLogRegisterBuffer(0, buffer, REGBUF_FORCE_IMAGE | REGBUF_STANDARD);
 
    recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_VACUUM_PAGE);
    PageSetLSN(page, recptr);
}

References Assert, BufferGetPage(), fb(), GinPageIsData, GinPageIsLeaf, PageSetLSN(), REGBUF_FORCE_IMAGE, REGBUF_STANDARD, RelationNeedsWAL, XLOG_GIN_VACUUM_PAGE, XLogBeginInsert(), XLogInsert(), and XLogRegisterBuffer().

Referenced by ginbulkdelete().