gistxlog.c File Reference

#include "postgres.h"
#include "access/bufmask.h"
#include "access/gist_private.h"
#include "access/gistxlog.h"
#include "access/heapam_xlog.h"
#include "access/transam.h"
#include "access/xloginsert.h"
#include "access/xlogutils.h"
#include "miscadmin.h"
#include "storage/procarray.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, SplitedPageLayout *dist, BlockNumber origrlink, GistNSN orignsn, Buffer leftchildbuf, bool markfollowright)
XLogRecPtr	gistXLogPageDelete (Buffer buffer, FullTransactionId xid, Buffer parentBuffer, OffsetNumber downlinkOffset)
XLogRecPtr	gistXLogAssignLSN (void)
void	gistXLogPageReuse (Relation rel, 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)

Variables
static MemoryContext	opCtx

Function Documentation

decodePageSplitRecord()

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

static

Definition at line 230 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(), i, IndexTupleSize, len, and palloc().

Referenced by gistRedoPageSplitRecord().

gist_mask()

void gist_mask	(	char *	pagedata,
		BlockNumber	blkno
	)

Definition at line 459 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 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 403 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;
        case XLOG_GIST_ASSIGN_LSN:
            /* nop. See gistGetFakeLSN(). */
            break;
        default:
            elog(PANIC, "gist_redo: unknown op code %u", info);
    }
 
    MemoryContextSwitchTo(oldCxt);
    MemoryContextReset(opCtx);
}

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

gist_xlog_cleanup()

void gist_xlog_cleanup

(

void

)

Definition at line 450 of file gistxlog.c.

{
    MemoryContextDelete(opCtx);
}

References MemoryContextDelete(), and opCtx.

gist_xlog_startup()

void gist_xlog_startup

(

void

)

Definition at line 444 of file gistxlog.c.

{
    opCtx = createTempGistContext();
}

References createTempGistContext(), and opCtx.

gistRedoClearFollowRight()

static void gistRedoClearFollowRight ( XLogReaderState *  record, uint8  block_id  )

static

Definition at line 42 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 generate_unaccent_rules::action, BLK_NEEDS_REDO, BLK_RESTORED, BufferGetPage(), BufferIsValid(), XLogReaderState::EndRecPtr, GistClearFollowRight, GistPageSetNSN, MarkBufferDirty(), PageSetLSN(), UnlockReleaseBuffer(), and XLogReadBufferForRedo().

Referenced by gistRedoPageSplitRecord(), and gistRedoPageUpdateRecord().

gistRedoDeleteRecord()

static void gistRedoDeleteRecord ( XLogReaderState *  record )

static

Definition at line 174 of file gistxlog.c.

{
    XLogRecPtr  lsn = record->EndRecPtr;
    gistxlogDelete *xldata = (gistxlogDelete *) XLogRecGetData(record);
    Buffer      buffer;
    Page        page;
 
    /*
     * 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 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,
                                            rlocator);
    }
 
    if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
    {
        page = (Page) BufferGetPage(buffer);
 
        if (XLogRecGetDataLen(record) > SizeOfGistxlogDelete)
        {
            OffsetNumber *todelete;
 
            todelete = (OffsetNumber *) ((char *) xldata + SizeOfGistxlogDelete);
 
            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, GistClearPageHasGarbage, GistMarkTuplesDeleted, InHotStandby, MarkBufferDirty(), gistxlogDelete::ntodelete, PageIndexMultiDelete(), PageSetLSN(), ResolveRecoveryConflictWithSnapshot(), SizeOfGistxlogDelete, gistxlogDelete::snapshotConflictHorizon, UnlockReleaseBuffer(), XLogReadBufferForRedo(), XLogRecGetBlockTag(), XLogRecGetData, and XLogRecGetDataLen.

Referenced by gist_redo().

gistRedoPageDelete()

static void gistRedoPageDelete ( XLogReaderState *  record )

static

Definition at line 349 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 = (Page) BufferGetPage(leafBuffer);
 
        GistPageSetDeleted(page, xldata->deleteXid);
 
        PageSetLSN(page, lsn);
        MarkBufferDirty(leafBuffer);
    }
 
    if (XLogReadBufferForRedo(record, 1, &parentBuffer) == BLK_NEEDS_REDO)
    {
        Page        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(), gistxlogPageDelete::deleteXid, gistxlogPageDelete::downlinkOffset, XLogReaderState::EndRecPtr, GistPageSetDeleted(), MarkBufferDirty(), PageIndexTupleDelete(), PageSetLSN(), UnlockReleaseBuffer(), XLogReadBufferForRedo(), and XLogRecGetData.

Referenced by gist_redo().

gistRedoPageReuse()

static void gistRedoPageReuse ( XLogReaderState *  record )

static

Definition at line 383 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->locator);
}

References InHotStandby, gistxlogPageReuse::locator, ResolveRecoveryConflictWithSnapshotFullXid(), gistxlogPageReuse::snapshotConflictHorizon, and XLogRecGetData.

Referenced by gist_redo().

gistRedoPageSplitRecord()

static void gistRedoPageSplitRecord ( XLogReaderState *  record )

static

Definition at line 254 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 = (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, FirstOffsetNumber, GIST_ROOT_BLKNO, GistClearFollowRight, gistfillbuffer(), GISTInitBuffer(), GistMarkFollowRight, GistPageGetOpaque, GistPageSetNSN, gistRedoClearFollowRight(), i, InvalidBlockNumber, InvalidBuffer, MarkBufferDirty(), gistxlogPageSplit::markfollowright, gistxlogPageSplit::npage, gistxlogPageSplit::origleaf, gistxlogPageSplit::orignsn, gistxlogPageSplit::origrlink, PageSetLSN(), UnlockReleaseBuffer(), XLogInitBufferForRedo(), XLogRecGetBlockData(), XLogRecGetBlockTag(), XLogRecGetData, and XLogRecHasBlockRef.

Referenced by gist_redo().

gistRedoPageUpdateRecord()

static void gistRedoPageUpdateRecord ( XLogReaderState *  record )

static

Definition at line 72 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 = (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, (Item) itup, itupsize))
                elog(ERROR, "failed to add item to GiST index page, size %d bytes",
                     (int) 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, (Item) itup, sz, off, false, false);
                if (l == InvalidOffsetNumber)
                    elog(ERROR, "failed to add item to GiST index page, size %d bytes",
                         (int) 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, FirstOffsetNumber, GistMarkTuplesDeleted, GistPageIsLeaf, gistRedoClearFollowRight(), IndexTupleSize, InvalidOffsetNumber, MarkBufferDirty(), gistxlogPageUpdate::ntodelete, gistxlogPageUpdate::ntoinsert, OffsetNumberNext, PageAddItem, PageGetMaxOffsetNumber(), PageIndexMultiDelete(), PageIndexTupleOverwrite(), PageIsEmpty(), PageSetLSN(), PG_USED_FOR_ASSERTS_ONLY, UnlockReleaseBuffer(), XLogReadBufferForRedo(), XLogRecGetBlockData(), XLogRecGetData, and XLogRecHasBlockRef.

Referenced by gist_redo().

gistXLogAssignLSN()

XLogRecPtr gistXLogAssignLSN

(

void

)

Definition at line 582 of file gistxlog.c.

{
    int         dummy = 0;
 
    /*
     * Records other than SWITCH_WAL must have content. We use an integer 0 to
     * follow the restriction.
     */
    XLogBeginInsert();
    XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
    XLogRegisterData((char *) &dummy, sizeof(dummy));
    return XLogInsert(RM_GIST_ID, XLOG_GIST_ASSIGN_LSN);
}

References XLOG_GIST_ASSIGN_LSN, XLOG_MARK_UNIMPORTANT, XLogBeginInsert(), XLogInsert(), XLogRegisterData(), and XLogSetRecordFlags().

Referenced by gistGetFakeLSN().

gistXLogDelete()

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

Definition at line 674 of file gistxlog.c.

{
    gistxlogDelete xlrec;
    XLogRecPtr  recptr;
 
    xlrec.snapshotConflictHorizon = snapshotConflictHorizon;
    xlrec.ntodelete = ntodelete;
 
    XLogBeginInsert();
    XLogRegisterData((char *) &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((char *) todelete, ntodelete * sizeof(OffsetNumber));
 
    XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
    recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_DELETE);
 
    return recptr;
}

References gistxlogDelete::ntodelete, REGBUF_STANDARD, SizeOfGistxlogDelete, gistxlogDelete::snapshotConflictHorizon, 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 558 of file gistxlog.c.

{
    gistxlogPageDelete xlrec;
    XLogRecPtr  recptr;
 
    xlrec.deleteXid = xid;
    xlrec.downlinkOffset = downlinkOffset;
 
    XLogBeginInsert();
    XLogRegisterData((char *) &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, gistxlogPageDelete::downlinkOffset, REGBUF_STANDARD, SizeOfGistxlogPageDelete, XLOG_GIST_PAGE_DELETE, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by gistdeletepage().

gistXLogPageReuse()

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

Definition at line 600 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.locator = rel->rd_locator;
    xlrec_reuse.block = blkno;
    xlrec_reuse.snapshotConflictHorizon = deleteXid;
 
    XLogBeginInsert();
    XLogRegisterData((char *) &xlrec_reuse, SizeOfGistxlogPageReuse);
 
    XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_REUSE);
}

References gistxlogPageReuse::block, gistxlogPageReuse::locator, RelationData::rd_locator, SizeOfGistxlogPageReuse, gistxlogPageReuse::snapshotConflictHorizon, XLOG_GIST_PAGE_REUSE, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by gistNewBuffer().

gistXLogSplit()

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

Definition at line 501 of file gistxlog.c.

{
    gistxlogPageSplit xlrec;
    SplitedPageLayout *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((char *) &xlrec, sizeof(gistxlogPageSplit));
 
    i = 1;
    for (ptr = dist; ptr; ptr = ptr->next)
    {
        XLogRegisterBuffer(i, ptr->buffer, REGBUF_WILL_INIT);
        XLogRegisterBufData(i, (char *) &(ptr->block.num), sizeof(int));
        XLogRegisterBufData(i, (char *) ptr->list, ptr->lenlist);
        i++;
    }
 
    recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_SPLIT);
 
    return recptr;
}

References SplitedPageLayout::block, SplitedPageLayout::buffer, BufferIsValid(), i, SplitedPageLayout::lenlist, SplitedPageLayout::list, gistxlogPageSplit::markfollowright, SplitedPageLayout::next, gistxlogPageSplit::npage, gistxlogPage::num, gistxlogPageSplit::origleaf, gistxlogPageSplit::orignsn, gistxlogPageSplit::origrlink, 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 633 of file gistxlog.c.

{
    gistxlogPageUpdate xlrec;
    int         i;
    XLogRecPtr  recptr;
 
    xlrec.ntodelete = ntodelete;
    xlrec.ntoinsert = ituplen;
 
    XLogBeginInsert();
    XLogRegisterData((char *) &xlrec, sizeof(gistxlogPageUpdate));
 
    XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
    XLogRegisterBufData(0, (char *) todelete, sizeof(OffsetNumber) * ntodelete);
 
    /* new tuples */
    for (i = 0; i < ituplen; i++)
        XLogRegisterBufData(0, (char *) (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(), i, IndexTupleSize, gistxlogPageUpdate::ntodelete, gistxlogPageUpdate::ntoinsert, 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 28 of file gistxlog.c.

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