gistxlog.c File Reference

#include "postgres.h"
#include "access/bufmask.h"
#include "access/gist_private.h"
#include "access/gistxlog.h"
#include "access/transam.h"
#include "access/xloginsert.h"
#include "access/xlogutils.h"
#include "storage/standby.h"
#include "utils/memutils.h"
#include "utils/rel.h"

Include dependency graph for gistxlog.c:

Go to the source code of this file.

Functions
static void	gistRedoClearFollowRight (XLogReaderState *record, uint8 block_id)
static void	gistRedoPageUpdateRecord (XLogReaderState *record)
static void	gistRedoDeleteRecord (XLogReaderState *record)
static IndexTuple *	decodePageSplitRecord (char *begin, int len, int *n)
static void	gistRedoPageSplitRecord (XLogReaderState *record)
static void	gistRedoPageDelete (XLogReaderState *record)
static void	gistRedoPageReuse (XLogReaderState *record)
void	gist_redo (XLogReaderState *record)
void	gist_xlog_startup (void)
void	gist_xlog_cleanup (void)
void	gist_mask (char *pagedata, BlockNumber blkno)
XLogRecPtr	gistXLogSplit (bool page_is_leaf, SplitPageLayout *dist, BlockNumber origrlink, GistNSN orignsn, Buffer leftchildbuf, bool markfollowright)
XLogRecPtr	gistXLogPageDelete (Buffer buffer, FullTransactionId xid, Buffer parentBuffer, OffsetNumber downlinkOffset)
void	gistXLogPageReuse (Relation rel, Relation heaprel, BlockNumber blkno, FullTransactionId deleteXid)
XLogRecPtr	gistXLogUpdate (Buffer buffer, OffsetNumber *todelete, int ntodelete, IndexTuple *itup, int ituplen, Buffer leftchildbuf)
XLogRecPtr	gistXLogDelete (Buffer buffer, OffsetNumber *todelete, int ntodelete, TransactionId snapshotConflictHorizon, Relation heaprel)

Variables
static MemoryContext	opCtx

Function Documentation

decodePageSplitRecord()

static IndexTuple * decodePageSplitRecord ( char *  begin, int  len, int *  n  )

static

Definition at line 221 of file gistxlog.c.

{
    char       *ptr;
    int         i = 0;
    IndexTuple *tuples;
 
    /* extract the number of tuples */
    memcpy(n, begin, sizeof(int));
    ptr = begin + sizeof(int);
 
    tuples = palloc(*n * sizeof(IndexTuple));
 
    for (i = 0; i < *n; i++)
    {
        Assert(ptr - begin < len);
        tuples[i] = (IndexTuple) ptr;
        ptr += IndexTupleSize((IndexTuple) ptr);
    }
    Assert(ptr - begin == len);
 
    return tuples;
}

References Assert, fb(), i, IndexTupleSize(), len, and palloc().

Referenced by gistRedoPageSplitRecord().

gist_mask()

void gist_mask	(	char *	pagedata,
		BlockNumber	blkno
	)

Definition at line 448 of file gistxlog.c.

{
    Page        page = (Page) pagedata;
 
    mask_page_lsn_and_checksum(page);
 
    mask_page_hint_bits(page);
    mask_unused_space(page);
 
    /*
     * NSN is nothing but a special purpose LSN. Hence, mask it for the same
     * reason as mask_page_lsn_and_checksum.
     */
    GistPageSetNSN(page, (uint64) MASK_MARKER);
 
    /*
     * We update F_FOLLOW_RIGHT flag on the left child after writing WAL
     * record. Hence, mask this flag. See gistplacetopage() for details.
     */
    GistMarkFollowRight(page);
 
    if (GistPageIsLeaf(page))
    {
        /*
         * In gist leaf pages, it is possible to modify the LP_FLAGS without
         * emitting any WAL record. Hence, mask the line pointer flags. See
         * gistkillitems() for details.
         */
        mask_lp_flags(page);
    }
 
    /*
     * During gist redo, we never mark a page as garbage. Hence, mask it to
     * ignore any differences.
     */
    GistClearPageHasGarbage(page);
}

References fb(), GistClearPageHasGarbage, GistMarkFollowRight, GistPageIsLeaf, GistPageSetNSN, mask_lp_flags(), MASK_MARKER, mask_page_hint_bits(), mask_page_lsn_and_checksum(), and mask_unused_space().

gist_redo()

void gist_redo

(

XLogReaderState *

record

)

Definition at line 395 of file gistxlog.c.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    MemoryContext oldCxt;
 
    /*
     * GiST indexes do not require any conflict processing. NB: If we ever
     * implement a similar optimization we have in b-tree, and remove killed
     * tuples outside VACUUM, we'll need to handle that here.
     */
 
    oldCxt = MemoryContextSwitchTo(opCtx);
    switch (info)
    {
        case XLOG_GIST_PAGE_UPDATE:
            gistRedoPageUpdateRecord(record);
            break;
        case XLOG_GIST_DELETE:
            gistRedoDeleteRecord(record);
            break;
        case XLOG_GIST_PAGE_REUSE:
            gistRedoPageReuse(record);
            break;
        case XLOG_GIST_PAGE_SPLIT:
            gistRedoPageSplitRecord(record);
            break;
        case XLOG_GIST_PAGE_DELETE:
            gistRedoPageDelete(record);
            break;
        default:
            elog(PANIC, "gist_redo: unknown op code %u", info);
    }
 
    MemoryContextSwitchTo(oldCxt);
    MemoryContextReset(opCtx);
}

References elog, fb(), gistRedoDeleteRecord(), gistRedoPageDelete(), gistRedoPageReuse(), gistRedoPageSplitRecord(), gistRedoPageUpdateRecord(), MemoryContextReset(), MemoryContextSwitchTo(), opCtx, PANIC, XLOG_GIST_DELETE, XLOG_GIST_PAGE_DELETE, XLOG_GIST_PAGE_REUSE, XLOG_GIST_PAGE_SPLIT, XLOG_GIST_PAGE_UPDATE, and XLogRecGetInfo.

gist_xlog_cleanup()

void gist_xlog_cleanup

(

void

)

Definition at line 439 of file gistxlog.c.

{
    MemoryContextDelete(opCtx);
}

References MemoryContextDelete(), and opCtx.

gist_xlog_startup()

void gist_xlog_startup

(

void

)

Definition at line 433 of file gistxlog.c.

{
    opCtx = createTempGistContext();
}

References createTempGistContext(), and opCtx.

gistRedoClearFollowRight()

static void gistRedoClearFollowRight ( XLogReaderState *  record, uint8  block_id  )

static

Definition at line 40 of file gistxlog.c.

{
    XLogRecPtr  lsn = record->EndRecPtr;
    Buffer      buffer;
    Page        page;
    XLogRedoAction action;
 
    /*
     * Note that we still update the page even if it was restored from a full
     * page image, because the updated NSN is not included in the image.
     */
    action = XLogReadBufferForRedo(record, block_id, &buffer);
    if (action == BLK_NEEDS_REDO || action == BLK_RESTORED)
    {
        page = BufferGetPage(buffer);
 
        GistPageSetNSN(page, lsn);
        GistClearFollowRight(page);
 
        PageSetLSN(page, lsn);
        MarkBufferDirty(buffer);
    }
    if (BufferIsValid(buffer))
        UnlockReleaseBuffer(buffer);
}

References BLK_NEEDS_REDO, BLK_RESTORED, BufferGetPage(), BufferIsValid(), XLogReaderState::EndRecPtr, fb(), GistClearFollowRight, GistPageSetNSN, MarkBufferDirty(), PageSetLSN(), UnlockReleaseBuffer(), and XLogReadBufferForRedo().

Referenced by gistRedoPageSplitRecord(), and gistRedoPageUpdateRecord().

gistRedoDeleteRecord()

static void gistRedoDeleteRecord ( XLogReaderState *  record )

static

Definition at line 170 of file gistxlog.c.

{
    XLogRecPtr  lsn = record->EndRecPtr;
    gistxlogDelete *xldata = (gistxlogDelete *) XLogRecGetData(record);
    Buffer      buffer;
    Page        page;
    OffsetNumber *toDelete = xldata->offsets;
 
    /*
     * If we have any conflict processing to do, it must happen before we
     * update the page.
     *
     * GiST delete records can conflict with standby queries.  You might think
     * that vacuum records would conflict as well, but we've handled that
     * already.  XLOG_HEAP2_PRUNE_VACUUM_SCAN records provide the highest xid
     * cleaned by the vacuum of the heap and so we can resolve any conflicts
     * just once when that arrives.  After that we know that no conflicts
     * exist from individual gist vacuum records on that index.
     */
    if (InHotStandby)
    {
        RelFileLocator rlocator;
 
        XLogRecGetBlockTag(record, 0, &rlocator, NULL, NULL);
 
        ResolveRecoveryConflictWithSnapshot(xldata->snapshotConflictHorizon,
                                            xldata->isCatalogRel,
                                            rlocator);
    }
 
    if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
    {
        page = BufferGetPage(buffer);
 
        PageIndexMultiDelete(page, toDelete, xldata->ntodelete);
 
        GistClearPageHasGarbage(page);
        GistMarkTuplesDeleted(page);
 
        PageSetLSN(page, lsn);
        MarkBufferDirty(buffer);
    }
 
    if (BufferIsValid(buffer))
        UnlockReleaseBuffer(buffer);
}

References BLK_NEEDS_REDO, BufferGetPage(), BufferIsValid(), XLogReaderState::EndRecPtr, fb(), GistClearPageHasGarbage, GistMarkTuplesDeleted, InHotStandby, MarkBufferDirty(), gistxlogDelete::offsets, PageIndexMultiDelete(), PageSetLSN(), ResolveRecoveryConflictWithSnapshot(), UnlockReleaseBuffer(), XLogReadBufferForRedo(), XLogRecGetBlockTag(), and XLogRecGetData.

Referenced by gist_redo().

gistRedoPageDelete()

static void gistRedoPageDelete ( XLogReaderState *  record )

static

Definition at line 340 of file gistxlog.c.

{
    XLogRecPtr  lsn = record->EndRecPtr;
    gistxlogPageDelete *xldata = (gistxlogPageDelete *) XLogRecGetData(record);
    Buffer      parentBuffer;
    Buffer      leafBuffer;
 
    if (XLogReadBufferForRedo(record, 0, &leafBuffer) == BLK_NEEDS_REDO)
    {
        Page        page = BufferGetPage(leafBuffer);
 
        GistPageSetDeleted(page, xldata->deleteXid);
 
        PageSetLSN(page, lsn);
        MarkBufferDirty(leafBuffer);
    }
 
    if (XLogReadBufferForRedo(record, 1, &parentBuffer) == BLK_NEEDS_REDO)
    {
        Page        page = BufferGetPage(parentBuffer);
 
        PageIndexTupleDelete(page, xldata->downlinkOffset);
 
        PageSetLSN(page, lsn);
        MarkBufferDirty(parentBuffer);
    }
 
    if (BufferIsValid(parentBuffer))
        UnlockReleaseBuffer(parentBuffer);
    if (BufferIsValid(leafBuffer))
        UnlockReleaseBuffer(leafBuffer);
}

References BLK_NEEDS_REDO, BufferGetPage(), BufferIsValid(), XLogReaderState::EndRecPtr, fb(), GistPageSetDeleted(), MarkBufferDirty(), PageIndexTupleDelete(), PageSetLSN(), UnlockReleaseBuffer(), XLogReadBufferForRedo(), and XLogRecGetData.

Referenced by gist_redo().

gistRedoPageReuse()

static void gistRedoPageReuse ( XLogReaderState *  record )

static

Definition at line 374 of file gistxlog.c.

{
    gistxlogPageReuse *xlrec = (gistxlogPageReuse *) XLogRecGetData(record);
 
    /*
     * PAGE_REUSE records exist to provide a conflict point when we reuse
     * pages in the index via the FSM.  That's all they do though.
     *
     * snapshotConflictHorizon was the page's deleteXid.  The
     * GlobalVisCheckRemovableFullXid(deleteXid) test in gistPageRecyclable()
     * conceptually mirrors the PGPROC->xmin > limitXmin test in
     * GetConflictingVirtualXIDs().  Consequently, one XID value achieves the
     * same exclusion effect on primary and standby.
     */
    if (InHotStandby)
        ResolveRecoveryConflictWithSnapshotFullXid(xlrec->snapshotConflictHorizon,
                                                   xlrec->isCatalogRel,
                                                   xlrec->locator);
}

References fb(), InHotStandby, ResolveRecoveryConflictWithSnapshotFullXid(), and XLogRecGetData.

Referenced by gist_redo().

gistRedoPageSplitRecord()

static void gistRedoPageSplitRecord ( XLogReaderState *  record )

static

Definition at line 245 of file gistxlog.c.

{
    XLogRecPtr  lsn = record->EndRecPtr;
    gistxlogPageSplit *xldata = (gistxlogPageSplit *) XLogRecGetData(record);
    Buffer      firstbuffer = InvalidBuffer;
    Buffer      buffer;
    Page        page;
    int         i;
    bool        isrootsplit = false;
 
    /*
     * We must hold lock on the first-listed page throughout the action,
     * including while updating the left child page (if any).  We can unlock
     * remaining pages in the list as soon as they've been written, because
     * there is no path for concurrent queries to reach those pages without
     * first visiting the first-listed page.
     */
 
    /* loop around all pages */
    for (i = 0; i < xldata->npage; i++)
    {
        int         flags;
        char       *data;
        Size        datalen;
        int         num;
        BlockNumber blkno;
        IndexTuple *tuples;
 
        XLogRecGetBlockTag(record, i + 1, NULL, NULL, &blkno);
        if (blkno == GIST_ROOT_BLKNO)
        {
            Assert(i == 0);
            isrootsplit = true;
        }
 
        buffer = XLogInitBufferForRedo(record, i + 1);
        page = BufferGetPage(buffer);
        data = XLogRecGetBlockData(record, i + 1, &datalen);
 
        tuples = decodePageSplitRecord(data, datalen, &num);
 
        /* ok, clear buffer */
        if (xldata->origleaf && blkno != GIST_ROOT_BLKNO)
            flags = F_LEAF;
        else
            flags = 0;
        GISTInitBuffer(buffer, flags);
 
        /* and fill it */
        gistfillbuffer(page, tuples, num, FirstOffsetNumber);
 
        if (blkno == GIST_ROOT_BLKNO)
        {
            GistPageGetOpaque(page)->rightlink = InvalidBlockNumber;
            GistPageSetNSN(page, xldata->orignsn);
            GistClearFollowRight(page);
        }
        else
        {
            if (i < xldata->npage - 1)
            {
                BlockNumber nextblkno;
 
                XLogRecGetBlockTag(record, i + 2, NULL, NULL, &nextblkno);
                GistPageGetOpaque(page)->rightlink = nextblkno;
            }
            else
                GistPageGetOpaque(page)->rightlink = xldata->origrlink;
            GistPageSetNSN(page, xldata->orignsn);
            if (i < xldata->npage - 1 && !isrootsplit &&
                xldata->markfollowright)
                GistMarkFollowRight(page);
            else
                GistClearFollowRight(page);
        }
 
        PageSetLSN(page, lsn);
        MarkBufferDirty(buffer);
 
        if (i == 0)
            firstbuffer = buffer;
        else
            UnlockReleaseBuffer(buffer);
    }
 
    /* Fix follow-right data on left child page, if any */
    if (XLogRecHasBlockRef(record, 0))
        gistRedoClearFollowRight(record, 0);
 
    /* Finally, release lock on the first page */
    UnlockReleaseBuffer(firstbuffer);
}

References Assert, BufferGetPage(), data, decodePageSplitRecord(), XLogReaderState::EndRecPtr, F_LEAF, fb(), FirstOffsetNumber, GIST_ROOT_BLKNO, GistClearFollowRight, gistfillbuffer(), GISTInitBuffer(), GistMarkFollowRight, GistPageGetOpaque, GistPageSetNSN, gistRedoClearFollowRight(), i, InvalidBlockNumber, InvalidBuffer, MarkBufferDirty(), PageSetLSN(), UnlockReleaseBuffer(), XLogInitBufferForRedo(), XLogRecGetBlockData(), XLogRecGetBlockTag(), XLogRecGetData, and XLogRecHasBlockRef.

Referenced by gist_redo().

gistRedoPageUpdateRecord()

static void gistRedoPageUpdateRecord ( XLogReaderState *  record )

static

Definition at line 70 of file gistxlog.c.

{
    XLogRecPtr  lsn = record->EndRecPtr;
    gistxlogPageUpdate *xldata = (gistxlogPageUpdate *) XLogRecGetData(record);
    Buffer      buffer;
    Page        page;
 
    if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
    {
        char       *begin;
        char       *data;
        Size        datalen;
        int         ninserted PG_USED_FOR_ASSERTS_ONLY = 0;
 
        data = begin = XLogRecGetBlockData(record, 0, &datalen);
 
        page = BufferGetPage(buffer);
 
        if (xldata->ntodelete == 1 && xldata->ntoinsert == 1)
        {
            /*
             * When replacing one tuple with one other tuple, we must use
             * PageIndexTupleOverwrite for consistency with gistplacetopage.
             */
            OffsetNumber offnum = *((OffsetNumber *) data);
            IndexTuple  itup;
            Size        itupsize;
 
            data += sizeof(OffsetNumber);
            itup = (IndexTuple) data;
            itupsize = IndexTupleSize(itup);
            if (!PageIndexTupleOverwrite(page, offnum, itup, itupsize))
                elog(ERROR, "failed to add item to GiST index page, size %zu bytes", itupsize);
            data += itupsize;
            /* should be nothing left after consuming 1 tuple */
            Assert(data - begin == datalen);
            /* update insertion count for assert check below */
            ninserted++;
        }
        else if (xldata->ntodelete > 0)
        {
            /* Otherwise, delete old tuples if any */
            OffsetNumber *todelete = (OffsetNumber *) data;
 
            data += sizeof(OffsetNumber) * xldata->ntodelete;
 
            PageIndexMultiDelete(page, todelete, xldata->ntodelete);
            if (GistPageIsLeaf(page))
                GistMarkTuplesDeleted(page);
        }
 
        /* Add new tuples if any */
        if (data - begin < datalen)
        {
            OffsetNumber off = (PageIsEmpty(page)) ? FirstOffsetNumber :
                OffsetNumberNext(PageGetMaxOffsetNumber(page));
 
            while (data - begin < datalen)
            {
                IndexTuple  itup = (IndexTuple) data;
                Size        sz = IndexTupleSize(itup);
                OffsetNumber l;
 
                data += sz;
 
                l = PageAddItem(page, itup, sz, off, false, false);
                if (l == InvalidOffsetNumber)
                    elog(ERROR, "failed to add item to GiST index page, size %zu bytes", sz);
                off++;
                ninserted++;
            }
        }
 
        /* Check that XLOG record contained expected number of tuples */
        Assert(ninserted == xldata->ntoinsert);
 
        PageSetLSN(page, lsn);
        MarkBufferDirty(buffer);
    }
 
    /*
     * Fix follow-right data on left child page
     *
     * This must be done while still holding the lock on the target page. Note
     * that even if the target page no longer exists, we still attempt to
     * replay the change on the child page.
     */
    if (XLogRecHasBlockRef(record, 1))
        gistRedoClearFollowRight(record, 1);
 
    if (BufferIsValid(buffer))
        UnlockReleaseBuffer(buffer);
}

References Assert, BLK_NEEDS_REDO, BufferGetPage(), BufferIsValid(), data, elog, XLogReaderState::EndRecPtr, ERROR, fb(), FirstOffsetNumber, GistMarkTuplesDeleted, GistPageIsLeaf, gistRedoClearFollowRight(), IndexTupleSize(), InvalidOffsetNumber, MarkBufferDirty(), OffsetNumberNext, PageAddItem, PageGetMaxOffsetNumber(), PageIndexMultiDelete(), PageIndexTupleOverwrite(), PageIsEmpty(), PageSetLSN(), PG_USED_FOR_ASSERTS_ONLY, UnlockReleaseBuffer(), XLogReadBufferForRedo(), XLogRecGetBlockData(), XLogRecGetData, and XLogRecHasBlockRef.

Referenced by gist_redo().

gistXLogDelete()

XLogRecPtr gistXLogDelete	(	Buffer	buffer,
		OffsetNumber *	todelete,
		int	ntodelete,
		TransactionId	snapshotConflictHorizon,
		Relation	heaprel
	)

Definition at line 647 of file gistxlog.c.

{
    gistxlogDelete xlrec;
    XLogRecPtr  recptr;
 
    xlrec.isCatalogRel = RelationIsAccessibleInLogicalDecoding(heaprel);
    xlrec.snapshotConflictHorizon = snapshotConflictHorizon;
    xlrec.ntodelete = ntodelete;
 
    XLogBeginInsert();
    XLogRegisterData(&xlrec, SizeOfGistxlogDelete);
 
    /*
     * We need the target-offsets array whether or not we store the whole
     * buffer, to allow us to find the snapshotConflictHorizon on a standby
     * server.
     */
    XLogRegisterData(todelete, ntodelete * sizeof(OffsetNumber));
 
    XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
    recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_DELETE);
 
    return recptr;
}

References fb(), gistxlogDelete::isCatalogRel, REGBUF_STANDARD, RelationIsAccessibleInLogicalDecoding, SizeOfGistxlogDelete, XLOG_GIST_DELETE, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by gistprunepage().

gistXLogPageDelete()

XLogRecPtr gistXLogPageDelete	(	Buffer	buffer,
		FullTransactionId	xid,
		Buffer	parentBuffer,
		OffsetNumber	downlinkOffset
	)

Definition at line 547 of file gistxlog.c.

{
    gistxlogPageDelete xlrec;
    XLogRecPtr  recptr;
 
    xlrec.deleteXid = xid;
    xlrec.downlinkOffset = downlinkOffset;
 
    XLogBeginInsert();
    XLogRegisterData(&xlrec, SizeOfGistxlogPageDelete);
 
    XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
    XLogRegisterBuffer(1, parentBuffer, REGBUF_STANDARD);
 
    recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_DELETE);
 
    return recptr;
}

References gistxlogPageDelete::deleteXid, fb(), REGBUF_STANDARD, SizeOfGistxlogPageDelete, XLOG_GIST_PAGE_DELETE, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by gistdeletepage().

gistXLogPageReuse()

void gistXLogPageReuse	(	Relation	rel,
		Relation	heaprel,
		BlockNumber	blkno,
		FullTransactionId	deleteXid
	)

Definition at line 571 of file gistxlog.c.

{
    gistxlogPageReuse xlrec_reuse;
 
    /*
     * Note that we don't register the buffer with the record, because this
     * operation doesn't modify the page. This record only exists to provide a
     * conflict point for Hot Standby.
     */
 
    /* XLOG stuff */
    xlrec_reuse.isCatalogRel = RelationIsAccessibleInLogicalDecoding(heaprel);
    xlrec_reuse.locator = rel->rd_locator;
    xlrec_reuse.block = blkno;
    xlrec_reuse.snapshotConflictHorizon = deleteXid;
 
    XLogBeginInsert();
    XLogRegisterData(&xlrec_reuse, SizeOfGistxlogPageReuse);
 
    XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_REUSE);
}

References fb(), gistxlogPageReuse::isCatalogRel, RelationData::rd_locator, RelationIsAccessibleInLogicalDecoding, SizeOfGistxlogPageReuse, XLOG_GIST_PAGE_REUSE, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by gistNewBuffer().

gistXLogSplit()

XLogRecPtr gistXLogSplit	(	bool	page_is_leaf,
		SplitPageLayout *	dist,
		BlockNumber	origrlink,
		GistNSN	orignsn,
		Buffer	leftchildbuf,
		bool	markfollowright
	)

Definition at line 490 of file gistxlog.c.

{
    gistxlogPageSplit xlrec;
    SplitPageLayout *ptr;
    int         npage = 0;
    XLogRecPtr  recptr;
    int         i;
 
    for (ptr = dist; ptr; ptr = ptr->next)
        npage++;
 
    xlrec.origrlink = origrlink;
    xlrec.orignsn = orignsn;
    xlrec.origleaf = page_is_leaf;
    xlrec.npage = (uint16) npage;
    xlrec.markfollowright = markfollowright;
 
    XLogBeginInsert();
 
    /*
     * Include a full page image of the child buf. (only necessary if a
     * checkpoint happened since the child page was split)
     */
    if (BufferIsValid(leftchildbuf))
        XLogRegisterBuffer(0, leftchildbuf, REGBUF_STANDARD);
 
    /*
     * NOTE: We register a lot of data. The caller must've called
     * XLogEnsureRecordSpace() to prepare for that. We cannot do it here,
     * because we're already in a critical section. If you change the number
     * of buffer or data registrations here, make sure you modify the
     * XLogEnsureRecordSpace() calls accordingly!
     */
    XLogRegisterData(&xlrec, sizeof(gistxlogPageSplit));
 
    i = 1;
    for (ptr = dist; ptr; ptr = ptr->next)
    {
        XLogRegisterBuffer(i, ptr->buffer, REGBUF_WILL_INIT);
        XLogRegisterBufData(i, &(ptr->block.num), sizeof(int));
        XLogRegisterBufData(i, ptr->list, ptr->lenlist);
        i++;
    }
 
    recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_SPLIT);
 
    return recptr;
}

References SplitPageLayout::block, SplitPageLayout::buffer, BufferIsValid(), fb(), i, SplitPageLayout::lenlist, SplitPageLayout::list, SplitPageLayout::next, gistxlogPage::num, REGBUF_STANDARD, REGBUF_WILL_INIT, XLOG_GIST_PAGE_SPLIT, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by gistplacetopage().

gistXLogUpdate()

XLogRecPtr gistXLogUpdate	(	Buffer	buffer,
		OffsetNumber *	todelete,
		int	ntodelete,
		IndexTuple *	itup,
		int	ituplen,
		Buffer	leftchildbuf
	)

Definition at line 606 of file gistxlog.c.

{
    gistxlogPageUpdate xlrec;
    int         i;
    XLogRecPtr  recptr;
 
    xlrec.ntodelete = ntodelete;
    xlrec.ntoinsert = ituplen;
 
    XLogBeginInsert();
    XLogRegisterData(&xlrec, sizeof(gistxlogPageUpdate));
 
    XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
    XLogRegisterBufData(0, todelete, sizeof(OffsetNumber) * ntodelete);
 
    /* new tuples */
    for (i = 0; i < ituplen; i++)
        XLogRegisterBufData(0, itup[i], IndexTupleSize(itup[i]));
 
    /*
     * Include a full page image of the child buf. (only necessary if a
     * checkpoint happened since the child page was split)
     */
    if (BufferIsValid(leftchildbuf))
        XLogRegisterBuffer(1, leftchildbuf, REGBUF_STANDARD);
 
    recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_UPDATE);
 
    return recptr;
}

References BufferIsValid(), fb(), i, IndexTupleSize(), gistxlogPageUpdate::ntodelete, REGBUF_STANDARD, XLOG_GIST_PAGE_UPDATE, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by gistplacetopage(), and gistvacuumpage().

Variable Documentation

opCtx

MemoryContext opCtx

static

Definition at line 26 of file gistxlog.c.

Referenced by gist_redo(), gist_xlog_cleanup(), and gist_xlog_startup().